From d46d96c71749e7349f865014fbcb5d1ae194fc40 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sun, 12 Jul 2026 02:18:59 -0700
Subject: [PATCH 01/22] Fix dropped carry in relaxed_u64_be_add_2_bytes

Byte 6 of the result returned the pre-carry `sum1` (u64[6] + bs[0])
instead of `sum1_with_carry`, silently dropping a carry propagating from
byte 7 into byte 6. The carry was still folded into the higher bytes via
carry2, so only byte 6 itself was wrong, and only when u64[7] + bs[1]
overflows. No current caller hits that path (they add pre-chunked
amounts whose low byte never carries at that position), so digests are
unchanged, but the helper was latently incorrect for a general 2-byte
big-endian add.
---
 Ix/IxVM/ByteStream.lean | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Ix/IxVM/ByteStream.lean b/Ix/IxVM/ByteStream.lean
index 8ed8c345..decd7af0 100644
--- a/Ix/IxVM/ByteStream.lean
+++ b/Ix/IxVM/ByteStream.lean
@@ -194,7 +194,7 @@ def byteStream := ⟦
     let (sum6, carry7) = u8_add(u64[1], carry6);
     let (sum7, _carry8) = u8_add(u64[0], carry7);
 
-    [sum7, sum6, sum5, sum4, sum3, sum2, sum1, sum0]
+    [sum7, sum6, sum5, sum4, sum3, sum2, sum1_with_carry, sum0]
   }
 
   fn u32_be_add(a: [U8; 4], b: [U8; 4]) -> [U8; 4] {

From fe796eb41b6049edab002965fb8b9237fef22bfa Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sat, 11 Jul 2026 05:58:28 -0700
Subject: [PATCH 02/22] Aiur sha256: inline round-body word ops as byte ops
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Each of the 17 u32_* helper calls per round (u32_xor 5, u32_and 5,
u32_be_add 7) cost 4 output auxiliaries + 1 lookup at the call site
plus a row in the helper's 26-35-wide circuit — 84% of total FFT sat
in three helper circuits. Rewrite the 64-round fold body with inline
u8_xor / u8_and ops and explicit big-endian u8_add carry chains
(carry-out is a free compound expression; mutually-exclusive carries
fold with field `+`, mirroring u32_be_add's internals). u32_and is
left with zero callers anywhere and is deleted from ByteStream.

Probed with a scratch execute-only stats driver (sha256_bench input
model with non-periodic LCG bytes so no memoization flatters the
numbers; 1 hash over 2048 bytes): total FFT cost 25,573,236 ->
11,046,080 (-56.8%). `lake test -- --ignored aiur-hashes` green
(execute, claim, prove/verify, all sizes).
---
 Ix/IxVM/ByteStream.lean |   8 ---
 Ix/IxVM/Sha256.lean     | 112 +++++++++++++++++++++++++++++++++++++---
 2 files changed, 104 insertions(+), 16 deletions(-)

diff --git a/Ix/IxVM/ByteStream.lean b/Ix/IxVM/ByteStream.lean
index decd7af0..3a04d92b 100644
--- a/Ix/IxVM/ByteStream.lean
+++ b/Ix/IxVM/ByteStream.lean
@@ -78,14 +78,6 @@ def byteStream := ⟦
     [c0, c1, c2, c3]
   }
 
-  fn u32_and(a: [U8; 4], b: [U8; 4]) -> [U8; 4] {
-    let c0 = u8_and(a[0], b[0]);
-    let c1 = u8_and(a[1], b[1]);
-    let c2 = u8_and(a[2], b[2]);
-    let c3 = u8_and(a[3], b[3]);
-    [c0, c1, c2, c3]
-  }
-
   -- Byte-by-byte `u64` equality
   fn u64_eq(a: U64, b: U64) -> G {
     let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
diff --git a/Ix/IxVM/Sha256.lean b/Ix/IxVM/Sha256.lean
index ca2b9085..b6c2fb9e 100644
--- a/Ix/IxVM/Sha256.lean
+++ b/Ix/IxVM/Sha256.lean
@@ -704,9 +704,64 @@ def sha256 := ⟦
 
       let e_not = [u8_from_field_unsafe(255 - to_field(acc[4][0])), u8_from_field_unsafe(255 - to_field(acc[4][1])), u8_from_field_unsafe(255 - to_field(acc[4][2])), u8_from_field_unsafe(255 - to_field(acc[4][3]))];
 
-      let s1 = u32_xor(e_rotr6, u32_xor(e_rotr11, e_rotr25));
-      let ch = u32_xor(u32_and(acc[4], acc[5]), u32_and(e_not, acc[6]));
-      let temp1 = u32_be_add(acc[7], u32_be_add(s1, u32_be_add(ch, u32_be_add(K[@i], W[@i]))));
+      -- Word ops inlined as byte ops (1 aux + 1 lookup each): a call to a
+      -- u32_* helper costs 4 output aux + 1 lookup here PLUS a row in the
+      -- helper's 26-35-wide circuit — the byte ops are less than half that.
+      let s1 = [
+        u8_xor(e_rotr6[0], u8_xor(e_rotr11[0], e_rotr25[0])),
+        u8_xor(e_rotr6[1], u8_xor(e_rotr11[1], e_rotr25[1])),
+        u8_xor(e_rotr6[2], u8_xor(e_rotr11[2], e_rotr25[2])),
+        u8_xor(e_rotr6[3], u8_xor(e_rotr11[3], e_rotr25[3]))
+      ];
+      let ch = [
+        u8_xor(u8_and(acc[4][0], acc[5][0]), u8_and(e_not[0], acc[6][0])),
+        u8_xor(u8_and(acc[4][1], acc[5][1]), u8_and(e_not[1], acc[6][1])),
+        u8_xor(u8_and(acc[4][2], acc[5][2]), u8_and(e_not[2], acc[6][2])),
+        u8_xor(u8_and(acc[4][3], acc[5][3]), u8_and(e_not[3], acc[6][3]))
+      ];
+      -- temp1 = h ⊞ s1 ⊞ ch ⊞ K[i] ⊞ W[i], big-endian byte-carry chains
+      -- (index 3 = LSB; carry folding mirrors `u32_be_add`).
+      let kw = K[@i];
+      let wi = W[@i];
+      let (kw0, kwc1) = u8_add(kw[3], wi[3]);
+      let (kwt1, kwo1) = u8_add(kw[2], wi[2]);
+      let (kw1, kwc1a) = u8_add(kwt1, kwc1);
+      let kwc2 = u8_from_field_unsafe(to_field(kwo1) + to_field(kwc1a));
+      let (kwt2, kwo2) = u8_add(kw[1], wi[1]);
+      let (kw2, kwc2a) = u8_add(kwt2, kwc2);
+      let kwc3 = u8_from_field_unsafe(to_field(kwo2) + to_field(kwc2a));
+      let (kwt3, _x) = u8_add(kw[0], wi[0]);
+      let (kw3, _x) = u8_add(kwt3, kwc3);
+
+      let (sc0, scc1) = u8_add(s1[3], ch[3]);
+      let (sct1, sco1) = u8_add(s1[2], ch[2]);
+      let (sc1, scc1a) = u8_add(sct1, scc1);
+      let scc2 = u8_from_field_unsafe(to_field(sco1) + to_field(scc1a));
+      let (sct2, sco2) = u8_add(s1[1], ch[1]);
+      let (sc2, scc2a) = u8_add(sct2, scc2);
+      let scc3 = u8_from_field_unsafe(to_field(sco2) + to_field(scc2a));
+      let (sct3, _x) = u8_add(s1[0], ch[0]);
+      let (sc3, _x) = u8_add(sct3, scc3);
+
+      let (hs0, hsc1) = u8_add(acc[7][3], sc0);
+      let (hst1, hso1) = u8_add(acc[7][2], sc1);
+      let (hs1, hsc1a) = u8_add(hst1, hsc1);
+      let hsc2 = u8_from_field_unsafe(to_field(hso1) + to_field(hsc1a));
+      let (hst2, hso2) = u8_add(acc[7][1], sc2);
+      let (hs2, hsc2a) = u8_add(hst2, hsc2);
+      let hsc3 = u8_from_field_unsafe(to_field(hso2) + to_field(hsc2a));
+      let (hst3, _x) = u8_add(acc[7][0], sc3);
+      let (hs3, _x) = u8_add(hst3, hsc3);
+
+      let (t10, t1c1) = u8_add(hs0, kw0);
+      let (t1t1, t1o1) = u8_add(hs1, kw1);
+      let (t11, t1c1a) = u8_add(t1t1, t1c1);
+      let t1c2 = u8_from_field_unsafe(to_field(t1o1) + to_field(t1c1a));
+      let (t1t2, t1o2) = u8_add(hs2, kw2);
+      let (t12, t1c2a) = u8_add(t1t2, t1c2);
+      let t1c3 = u8_from_field_unsafe(to_field(t1o2) + to_field(t1c2a));
+      let (t1t3, _x) = u8_add(hs3, kw3);
+      let (t13, _x) = u8_add(t1t3, t1c3);
 
       let a_0_bits = u8_bit_decomposition(acc[0][3]);
       let a_1_bits = u8_bit_decomposition(acc[0][2]);
@@ -734,11 +789,52 @@ def sha256 := ⟦
         u8_from_field_unsafe(a_2_bits[6] + 2 * a_2_bits[7] + 4 * a_3_bits[0] + 8 * a_3_bits[1] + 16 * a_3_bits[2] + 32 * a_3_bits[3] + 64 * a_3_bits[4] + 128 * a_3_bits[5])
       ];
 
-      let s0 = u32_xor(a_rotr2, u32_xor(a_rotr13, a_rotr22));
-      let maj = u32_xor(u32_and(acc[0], acc[1]), u32_xor(u32_and(acc[0], acc[2]), u32_and(acc[1], acc[2])));
-      let temp2 = u32_be_add(s0, maj);
-
-      [u32_be_add(temp1, temp2), acc[0], acc[1], acc[2], u32_be_add(acc[3], temp1), acc[4], acc[5], acc[6]]
+      let s0 = [
+        u8_xor(a_rotr2[0], u8_xor(a_rotr13[0], a_rotr22[0])),
+        u8_xor(a_rotr2[1], u8_xor(a_rotr13[1], a_rotr22[1])),
+        u8_xor(a_rotr2[2], u8_xor(a_rotr13[2], a_rotr22[2])),
+        u8_xor(a_rotr2[3], u8_xor(a_rotr13[3], a_rotr22[3]))
+      ];
+      let maj = [
+        u8_xor(u8_and(acc[0][0], acc[1][0]), u8_xor(u8_and(acc[0][0], acc[2][0]), u8_and(acc[1][0], acc[2][0]))),
+        u8_xor(u8_and(acc[0][1], acc[1][1]), u8_xor(u8_and(acc[0][1], acc[2][1]), u8_and(acc[1][1], acc[2][1]))),
+        u8_xor(u8_and(acc[0][2], acc[1][2]), u8_xor(u8_and(acc[0][2], acc[2][2]), u8_and(acc[1][2], acc[2][2]))),
+        u8_xor(u8_and(acc[0][3], acc[1][3]), u8_xor(u8_and(acc[0][3], acc[2][3]), u8_and(acc[1][3], acc[2][3])))
+      ];
+      -- temp2 = s0 ⊞ maj
+      let (t20, t2c1) = u8_add(s0[3], maj[3]);
+      let (t2t1, t2o1) = u8_add(s0[2], maj[2]);
+      let (t21, t2c1a) = u8_add(t2t1, t2c1);
+      let t2c2 = u8_from_field_unsafe(to_field(t2o1) + to_field(t2c1a));
+      let (t2t2, t2o2) = u8_add(s0[1], maj[1]);
+      let (t22, t2c2a) = u8_add(t2t2, t2c2);
+      let t2c3 = u8_from_field_unsafe(to_field(t2o2) + to_field(t2c2a));
+      let (t2t3, _x) = u8_add(s0[0], maj[0]);
+      let (t23, _x) = u8_add(t2t3, t2c3);
+
+      -- a' = temp1 ⊞ temp2
+      let (na0, nac1) = u8_add(t10, t20);
+      let (nat1, nao1) = u8_add(t11, t21);
+      let (na1, nac1a) = u8_add(nat1, nac1);
+      let nac2 = u8_from_field_unsafe(to_field(nao1) + to_field(nac1a));
+      let (nat2, nao2) = u8_add(t12, t22);
+      let (na2, nac2a) = u8_add(nat2, nac2);
+      let nac3 = u8_from_field_unsafe(to_field(nao2) + to_field(nac2a));
+      let (nat3, _x) = u8_add(t13, t23);
+      let (na3, _x) = u8_add(nat3, nac3);
+
+      -- e' = d ⊞ temp1
+      let (ne0, nec1) = u8_add(acc[3][3], t10);
+      let (net1, neo1) = u8_add(acc[3][2], t11);
+      let (ne1, nec1a) = u8_add(net1, nec1);
+      let nec2 = u8_from_field_unsafe(to_field(neo1) + to_field(nec1a));
+      let (net2, neo2) = u8_add(acc[3][1], t12);
+      let (ne2, nec2a) = u8_add(net2, nec2);
+      let nec3 = u8_from_field_unsafe(to_field(neo2) + to_field(nec2a));
+      let (net3, _x) = u8_add(acc[3][0], t13);
+      let (ne3, _x) = u8_add(net3, nec3);
+
+      [[na3, na2, na1, na0], acc[0], acc[1], acc[2], [ne3, ne2, ne1, ne0], acc[4], acc[5], acc[6]]
     );
 
     [

From fa199b738e69a7e021d22293c4e6464a2469f195 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sat, 11 Jul 2026 06:38:58 -0700
Subject: [PATCH 03/22] Aiur sha256: inline the message schedule into the block
 circuit
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`define_W_i` cost 4 output aux + 1 lookup per call site plus a
210-wide row per (W_i-2, W_i-7, W_i-15, W_i-16) tuple in its own
circuit — 48 rows per block at a taller height's log2, re-paying its
16 input columns per row, all through u32_xor/u32_be_add calls.
In-block, the schedule rides rows that already exist at log2(blocks),
with the word ops inlined as byte ops. The final Davies-Meyer state
addition loses its 8 u32_be_add calls the same way. u32_xor and
u32_be_add are left with zero callers anywhere and are deleted from
ByteStream. shr10's top byte is the constant 0, so s1's byte 0 xors
two operands instead of three.

The schedule fold indexes W[i-2]/W[i-7]/W[i-15]/W[i-16], which the
fold macro could not express: add an `arr[@i - k]` form (literal
offset, resolved to a static index during unrolling). The unrolled
body needs maxRecDepth 65536 to elaborate.

Scratch probe (sha256_bench model, non-periodic LCG bytes, 1 hash
over 2048 bytes): total FFT cost 11,046,080 -> 5,906,938 (-46.5%,
zero cache hits; -76.9% from the branch baseline's 25,573,236), now
10% below blake3's 6,575,392 on the same input.
fill_W_and_run_rounds is 93% of remaining cost (width 33,038 x 33
rows). `lake test -- --ignored aiur-hashes` green (execute, claim,
prove/verify, all sizes).
---
 Ix/Aiur/Meta.lean       |   8 ++
 Ix/IxVM/ByteStream.lean |  29 -----
 Ix/IxVM/Sha256.lean     | 259 ++++++++++++++++++++--------------------
 3 files changed, 138 insertions(+), 158 deletions(-)

diff --git a/Ix/Aiur/Meta.lean b/Ix/Aiur/Meta.lean
index 19d6a05f..c215e69c 100644
--- a/Ix/Aiur/Meta.lean
+++ b/Ix/Aiur/Meta.lean
@@ -207,6 +207,7 @@ syntax:max num "u8"                                                         : ai
 syntax "dbg!" "(" str (", " aiur_trm)? ")" ";" (aiur_trm)?                  : aiur_trm
 
 syntax aiur_trm "[" "@" noWs ident "]"                                                              : aiur_trm
+syntax aiur_trm "[" "@" noWs ident " - " num "]"                                                    : aiur_trm
 syntax "set" "(" aiur_trm ", " "@" noWs ident ", " aiur_trm ")"                                     : aiur_trm
 syntax "fold" "(" num ".." num ", " aiur_trm ", " "|" aiur_pattern ", " "@" noWs ident "|" aiur_trm ")" : aiur_trm
 
@@ -389,6 +390,7 @@ partial def elabTrm : ElabStxCat `aiur_trm
       res ← `(aiur_trm| let $acc = $res; $body')
     elabTrm res
   | `(aiur_trm| $_[@$var]) => throw $ .error var "Unbound macro variable"
+  | `(aiur_trm| $_[@$var - $_:num]) => throw $ .error var "Unbound macro variable"
   | `(aiur_trm| set($_, @$var, $_)) => throw $ .error var "Unbound macro variable"
   | stx => throw $ .error stx "Invalid syntax for term"
 where
@@ -402,6 +404,12 @@ where
         let new := Syntax.mkNatLit new
         `(aiur_trm| $arr[$new])
       else `(aiur_trm| $arr[@$var])
+    | `(aiur_trm| $arr[@$var - $k:num]) => do
+      let arr ← replaceToken old new arr
+      if var.getId = old then
+        let new := Syntax.mkNatLit (new - k.getNat)
+        `(aiur_trm| $arr[$new])
+      else `(aiur_trm| $arr[@$var - $k:num])
     | `(aiur_trm| set($arr, @$var, $v)) => do
       let arr ← replaceToken old new arr
       let v ← replaceToken old new v
diff --git a/Ix/IxVM/ByteStream.lean b/Ix/IxVM/ByteStream.lean
index 3a04d92b..385bc7bb 100644
--- a/Ix/IxVM/ByteStream.lean
+++ b/Ix/IxVM/ByteStream.lean
@@ -70,14 +70,6 @@ def byteStream := ⟦
     [sum0, sum1_with_carry, sum2_with_carry, sum3_with_carry]
   }
 
-  fn u32_xor(a: [U8; 4], b: [U8; 4]) -> [U8; 4] {
-    let c0 = u8_xor(a[0], b[0]);
-    let c1 = u8_xor(a[1], b[1]);
-    let c2 = u8_xor(a[2], b[2]);
-    let c3 = u8_xor(a[3], b[3]);
-    [c0, c1, c2, c3]
-  }
-
   -- Byte-by-byte `u64` equality
   fn u64_eq(a: U64, b: U64) -> G {
     let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
@@ -189,27 +181,6 @@ def byteStream := ⟦
     [sum7, sum6, sum5, sum4, sum3, sum2, sum1_with_carry, sum0]
   }
 
-  fn u32_be_add(a: [U8; 4], b: [U8; 4]) -> [U8; 4] {
-    -- Byte 0, no initial carry
-    let (sum0, carry1) = u8_add(a[3], b[3]);
-
-    -- Byte 1
-    let (sum1, overflow1) = u8_add(a[2], b[2]);
-    let (sum1_with_carry, carry1a) = u8_add(sum1, carry1);
-    let carry2 = u8_from_field_unsafe(to_field(overflow1) + to_field(carry1a));
-
-    -- Byte 2
-    let (sum2, overflow2) = u8_add(a[1], b[1]);
-    let (sum2_with_carry, carry2a) = u8_add(sum2, carry2);
-    let carry3 = u8_from_field_unsafe(to_field(overflow2) + to_field(carry2a));
-
-    -- Byte 3
-    let (sum3, _x) = u8_add(a[0], b[0]);
-    let (sum3_with_carry, _x) = u8_add(sum3, carry3);
-
-    [sum3_with_carry, sum2_with_carry, sum1_with_carry, sum0]
-  }
-
   -- Computes the predecessor of an `u64` assumed to be properly represented in
   -- little-endian bytes. If that's not the case, this implementation has UB.
   fn relaxed_u64_pred(bytes: U64) -> U64 {
diff --git a/Ix/IxVM/Sha256.lean b/Ix/IxVM/Sha256.lean
index b6c2fb9e..5388ad17 100644
--- a/Ix/IxVM/Sha256.lean
+++ b/Ix/IxVM/Sha256.lean
@@ -5,6 +5,9 @@ public section
 
 namespace IxVM
 
+-- The unrolled message schedule + 64-round fold elaborate to one deeply
+-- nested let chain; the default recursion budget is not enough.
+set_option maxRecDepth 65536 in
 def sha256 := ⟦
   /- # Test entrypoints -/
 
@@ -613,65 +616,116 @@ def sha256 := ⟦
       [0x90u8, 0xbeu8, 0xffu8, 0xfau8], [0xa4u8, 0x50u8, 0x6cu8, 0xebu8], [0xbeu8, 0xf9u8, 0xa3u8, 0xf7u8], [0xc6u8, 0x71u8, 0x78u8, 0xf2u8]
     ];
 
-    let W_16 = define_W_i(W[14], W[9],  W[1],  W[0]);
-    let W_17 = define_W_i(W[15], W[10], W[2],  W[1]);
-    let W_18 = define_W_i(W_16,  W[11], W[3],  W[2]);
-    let W_19 = define_W_i(W_17,  W[12], W[4],  W[3]);
-    let W_20 = define_W_i(W_18,  W[13], W[5],  W[4]);
-    let W_21 = define_W_i(W_19,  W[14], W[6],  W[5]);
-    let W_22 = define_W_i(W_20,  W[15], W[7],  W[6]);
-    let W_23 = define_W_i(W_21,  W_16,  W[8],  W[7]);
-    let W_24 = define_W_i(W_22,  W_17,  W[9],  W[8]);
-    let W_25 = define_W_i(W_23,  W_18,  W[10], W[9]);
-    let W_26 = define_W_i(W_24,  W_19,  W[11], W[10]);
-    let W_27 = define_W_i(W_25,  W_20,  W[12], W[11]);
-    let W_28 = define_W_i(W_26,  W_21,  W[13], W[12]);
-    let W_29 = define_W_i(W_27,  W_22,  W[14], W[13]);
-    let W_30 = define_W_i(W_28,  W_23,  W[15], W[14]);
-    let W_31 = define_W_i(W_29,  W_24,  W_16,  W[15]);
-    let W_32 = define_W_i(W_30,  W_25,  W_17,  W_16);
-    let W_33 = define_W_i(W_31,  W_26,  W_18,  W_17);
-    let W_34 = define_W_i(W_32,  W_27,  W_19,  W_18);
-    let W_35 = define_W_i(W_33,  W_28,  W_20,  W_19);
-    let W_36 = define_W_i(W_34,  W_29,  W_21,  W_20);
-    let W_37 = define_W_i(W_35,  W_30,  W_22,  W_21);
-    let W_38 = define_W_i(W_36,  W_31,  W_23,  W_22);
-    let W_39 = define_W_i(W_37,  W_32,  W_24,  W_23);
-    let W_40 = define_W_i(W_38,  W_33,  W_25,  W_24);
-    let W_41 = define_W_i(W_39,  W_34,  W_26,  W_25);
-    let W_42 = define_W_i(W_40,  W_35,  W_27,  W_26);
-    let W_43 = define_W_i(W_41,  W_36,  W_28,  W_27);
-    let W_44 = define_W_i(W_42,  W_37,  W_29,  W_28);
-    let W_45 = define_W_i(W_43,  W_38,  W_30,  W_29);
-    let W_46 = define_W_i(W_44,  W_39,  W_31,  W_30);
-    let W_47 = define_W_i(W_45,  W_40,  W_32,  W_31);
-    let W_48 = define_W_i(W_46,  W_41,  W_33,  W_32);
-    let W_49 = define_W_i(W_47,  W_42,  W_34,  W_33);
-    let W_50 = define_W_i(W_48,  W_43,  W_35,  W_34);
-    let W_51 = define_W_i(W_49,  W_44,  W_36,  W_35);
-    let W_52 = define_W_i(W_50,  W_45,  W_37,  W_36);
-    let W_53 = define_W_i(W_51,  W_46,  W_38,  W_37);
-    let W_54 = define_W_i(W_52,  W_47,  W_39,  W_38);
-    let W_55 = define_W_i(W_53,  W_48,  W_40,  W_39);
-    let W_56 = define_W_i(W_54,  W_49,  W_41,  W_40);
-    let W_57 = define_W_i(W_55,  W_50,  W_42,  W_41);
-    let W_58 = define_W_i(W_56,  W_51,  W_43,  W_42);
-    let W_59 = define_W_i(W_57,  W_52,  W_44,  W_43);
-    let W_60 = define_W_i(W_58,  W_53,  W_45,  W_44);
-    let W_61 = define_W_i(W_59,  W_54,  W_46,  W_45);
-    let W_62 = define_W_i(W_60,  W_55,  W_47,  W_46);
-    let W_63 = define_W_i(W_61,  W_56,  W_48,  W_47);
-
-    let W = [
-      W[0], W[1], W[2],  W[3],  W[4],  W[5],  W[6],  W[7],
-      W[8], W[9], W[10], W[11], W[12], W[13], W[14], W[15],
-      W_16, W_17, W_18,  W_19,  W_20,  W_21,  W_22,  W_23,
-      W_24, W_25, W_26,  W_27,  W_28,  W_29,  W_30,  W_31,
-      W_32, W_33, W_34,  W_35,  W_36,  W_37,  W_38,  W_39,
-      W_40, W_41, W_42,  W_43,  W_44,  W_45,  W_46,  W_47,
-      W_48, W_49, W_50,  W_51,  W_52,  W_53,  W_54,  W_55,
-      W_56, W_57, W_58,  W_59,  W_60,  W_61,  W_62,  W_63
-    ];
+    -- Message schedule, inlined (the old `define_W_i` helper's body): each
+    -- call cost 4 output aux + 1 lookup here plus a 210-wide row per
+    -- distinct input tuple in its own circuit — with the schedule in-block
+    -- the work rides the block row that already exists.
+    let Wx = [[0u8; 4]; 64];
+    let Wx = fold(0 .. 16, Wx, |Wx, @j| set(Wx, @j, W[@j]));
+    let Wx = fold(16 .. 64, Wx, |Wx, @i|
+      let [w15_b3, w15_b2, w15_b1, w15_b0] = Wx[@i - 15];
+      let [w15_b0_0, w15_b0_1, w15_b0_2, w15_b0_3, w15_b0_4, w15_b0_5, w15_b0_6, w15_b0_7] = u8_bit_decomposition(w15_b0);
+      let [w15_b1_0, w15_b1_1, w15_b1_2, w15_b1_3, w15_b1_4, w15_b1_5, w15_b1_6, w15_b1_7] = u8_bit_decomposition(w15_b1);
+      let [w15_b2_0, w15_b2_1, w15_b2_2, w15_b2_3, w15_b2_4, w15_b2_5, w15_b2_6, w15_b2_7] = u8_bit_decomposition(w15_b2);
+      let [w15_b3_0, w15_b3_1, w15_b3_2, w15_b3_3, w15_b3_4, w15_b3_5, w15_b3_6, w15_b3_7] = u8_bit_decomposition(w15_b3);
+
+      let w15_rotr7 = [
+        u8_from_field_unsafe(w15_b3_7 + 2 * w15_b0_0 + 4 * w15_b0_1 + 8 * w15_b0_2 + 16 * w15_b0_3 + 32 * w15_b0_4 + 64 * w15_b0_5 + 128 * w15_b0_6),
+        u8_from_field_unsafe(w15_b2_7 + 2 * w15_b3_0 + 4 * w15_b3_1 + 8 * w15_b3_2 + 16 * w15_b3_3 + 32 * w15_b3_4 + 64 * w15_b3_5 + 128 * w15_b3_6),
+        u8_from_field_unsafe(w15_b1_7 + 2 * w15_b2_0 + 4 * w15_b2_1 + 8 * w15_b2_2 + 16 * w15_b2_3 + 32 * w15_b2_4 + 64 * w15_b2_5 + 128 * w15_b2_6),
+        u8_from_field_unsafe(w15_b0_7 + 2 * w15_b1_0 + 4 * w15_b1_1 + 8 * w15_b1_2 + 16 * w15_b1_3 + 32 * w15_b1_4 + 64 * w15_b1_5 + 128 * w15_b1_6)
+      ];
+
+      let w15_rotr18 = [
+        u8_from_field_unsafe(w15_b1_2 + 2 * w15_b1_3 + 4 * w15_b1_4 + 8 * w15_b1_5 + 16 * w15_b1_6 + 32 * w15_b1_7 + 64 * w15_b2_0 + 128 * w15_b2_1),
+        u8_from_field_unsafe(w15_b0_2 + 2 * w15_b0_3 + 4 * w15_b0_4 + 8 * w15_b0_5 + 16 * w15_b0_6 + 32 * w15_b0_7 + 64 * w15_b1_0 + 128 * w15_b1_1),
+        u8_from_field_unsafe(w15_b3_2 + 2 * w15_b3_3 + 4 * w15_b3_4 + 8 * w15_b3_5 + 16 * w15_b3_6 + 32 * w15_b3_7 + 64 * w15_b0_0 + 128 * w15_b0_1),
+        u8_from_field_unsafe(w15_b2_2 + 2 * w15_b2_3 + 4 * w15_b2_4 + 8 * w15_b2_5 + 16 * w15_b2_6 + 32 * w15_b2_7 + 64 * w15_b3_0 + 128 * w15_b3_1)
+      ];
+
+      let w15_shr3 = [
+        u8_from_field_unsafe(w15_b3_3 + 2 * w15_b3_4 + 4 * w15_b3_5 + 8 * w15_b3_6 + 16 * w15_b3_7),
+        u8_from_field_unsafe(w15_b2_3 + 2 * w15_b2_4 + 4 * w15_b2_5 + 8 * w15_b2_6 + 16 * w15_b2_7 + 32 * w15_b3_0 + 64 * w15_b3_1 + 128 * w15_b3_2),
+        u8_from_field_unsafe(w15_b1_3 + 2 * w15_b1_4 + 4 * w15_b1_5 + 8 * w15_b1_6 + 16 * w15_b1_7 + 32 * w15_b2_0 + 64 * w15_b2_1 + 128 * w15_b2_2),
+        u8_from_field_unsafe(w15_b0_3 + 2 * w15_b0_4 + 4 * w15_b0_5 + 8 * w15_b0_6 + 16 * w15_b0_7 + 32 * w15_b1_0 + 64 * w15_b1_1 + 128 * w15_b1_2)
+      ];
+
+      let [w2_b3, w2_b2, w2_b1, w2_b0] = Wx[@i - 2];
+      let [w2_b0_0, w2_b0_1, w2_b0_2, w2_b0_3, w2_b0_4, w2_b0_5, w2_b0_6, w2_b0_7] = u8_bit_decomposition(w2_b0);
+      let [w2_b1_0, w2_b1_1, w2_b1_2, w2_b1_3, w2_b1_4, w2_b1_5, w2_b1_6, w2_b1_7] = u8_bit_decomposition(w2_b1);
+      let [w2_b2_0, w2_b2_1, w2_b2_2, w2_b2_3, w2_b2_4, w2_b2_5, w2_b2_6, w2_b2_7] = u8_bit_decomposition(w2_b2);
+      let [w2_b3_0, w2_b3_1, w2_b3_2, w2_b3_3, w2_b3_4, w2_b3_5, w2_b3_6, w2_b3_7] = u8_bit_decomposition(w2_b3);
+
+      let w2_rotr17 = [
+        u8_from_field_unsafe(w2_b1_1 + 2 * w2_b1_2 + 4 * w2_b1_3 + 8 * w2_b1_4 + 16 * w2_b1_5 + 32 * w2_b1_6 + 64 * w2_b1_7 + 128 * w2_b2_0),
+        u8_from_field_unsafe(w2_b0_1 + 2 * w2_b0_2 + 4 * w2_b0_3 + 8 * w2_b0_4 + 16 * w2_b0_5 + 32 * w2_b0_6 + 64 * w2_b0_7 + 128 * w2_b1_0),
+        u8_from_field_unsafe(w2_b3_1 + 2 * w2_b3_2 + 4 * w2_b3_3 + 8 * w2_b3_4 + 16 * w2_b3_5 + 32 * w2_b3_6 + 64 * w2_b3_7 + 128 * w2_b0_0),
+        u8_from_field_unsafe(w2_b2_1 + 2 * w2_b2_2 + 4 * w2_b2_3 + 8 * w2_b2_4 + 16 * w2_b2_5 + 32 * w2_b2_6 + 64 * w2_b2_7 + 128 * w2_b3_0)
+      ];
+
+      let w2_rotr19 = [
+        u8_from_field_unsafe(w2_b1_3 + 2 * w2_b1_4 + 4 * w2_b1_5 + 8 * w2_b1_6 + 16 * w2_b1_7 + 32 * w2_b2_0 + 64 * w2_b2_1 + 128 * w2_b2_2),
+        u8_from_field_unsafe(w2_b0_3 + 2 * w2_b0_4 + 4 * w2_b0_5 + 8 * w2_b0_6 + 16 * w2_b0_7 + 32 * w2_b1_0 + 64 * w2_b1_1 + 128 * w2_b1_2),
+        u8_from_field_unsafe(w2_b3_3 + 2 * w2_b3_4 + 4 * w2_b3_5 + 8 * w2_b3_6 + 16 * w2_b3_7 + 32 * w2_b0_0 + 64 * w2_b0_1 + 128 * w2_b0_2),
+        u8_from_field_unsafe(w2_b2_3 + 2 * w2_b2_4 + 4 * w2_b2_5 + 8 * w2_b2_6 + 16 * w2_b2_7 + 32 * w2_b3_0 + 64 * w2_b3_1 + 128 * w2_b3_2)
+      ];
+
+      -- shr10's top byte is the constant 0; only the three live bytes are
+      -- materialized, and s1's byte 0 xors two operands instead of three.
+      let w2_shr10 = [
+        u8_from_field_unsafe(w2_b3_2 + 2 * w2_b3_3 + 4 * w2_b3_4 + 8 * w2_b3_5 + 16 * w2_b3_6 + 32 * w2_b3_7),
+        u8_from_field_unsafe(w2_b2_2 + 2 * w2_b2_3 + 4 * w2_b2_4 + 8 * w2_b2_5 + 16 * w2_b2_6 + 32 * w2_b2_7 + 64 * w2_b3_0 + 128 * w2_b3_1),
+        u8_from_field_unsafe(w2_b1_2 + 2 * w2_b1_3 + 4 * w2_b1_4 + 8 * w2_b1_5 + 16 * w2_b1_6 + 32 * w2_b1_7 + 64 * w2_b2_0 + 128 * w2_b2_1)
+      ];
+
+      let ws0 = [
+        u8_xor(w15_rotr7[0], u8_xor(w15_rotr18[0], w15_shr3[0])),
+        u8_xor(w15_rotr7[1], u8_xor(w15_rotr18[1], w15_shr3[1])),
+        u8_xor(w15_rotr7[2], u8_xor(w15_rotr18[2], w15_shr3[2])),
+        u8_xor(w15_rotr7[3], u8_xor(w15_rotr18[3], w15_shr3[3]))
+      ];
+      let ws1 = [
+        u8_xor(w2_rotr17[0], w2_rotr19[0]),
+        u8_xor(w2_rotr17[1], u8_xor(w2_rotr19[1], w2_shr10[0])),
+        u8_xor(w2_rotr17[2], u8_xor(w2_rotr19[2], w2_shr10[1])),
+        u8_xor(w2_rotr17[3], u8_xor(w2_rotr19[3], w2_shr10[2]))
+      ];
+
+      -- W_i = W_i-16 ⊞ s0 ⊞ W_i-7 ⊞ s1 (big-endian u8_add carry chains).
+      let (ss0, ssc1) = u8_add(ws0[3], ws1[3]);
+      let (sst1, sso1) = u8_add(ws0[2], ws1[2]);
+      let (ss1, ssc1a) = u8_add(sst1, ssc1);
+      let ssc2 = u8_from_field_unsafe(to_field(sso1) + to_field(ssc1a));
+      let (sst2, sso2) = u8_add(ws0[1], ws1[1]);
+      let (ss2, ssc2a) = u8_add(sst2, ssc2);
+      let ssc3 = u8_from_field_unsafe(to_field(sso2) + to_field(ssc2a));
+      let (sst3, _x) = u8_add(ws0[0], ws1[0]);
+      let (ss3, _x) = u8_add(sst3, ssc3);
+
+      let w16 = Wx[@i - 16];
+      let w7 = Wx[@i - 7];
+      let (ww0, wwc1) = u8_add(w16[3], w7[3]);
+      let (wwt1, wwo1) = u8_add(w16[2], w7[2]);
+      let (ww1, wwc1a) = u8_add(wwt1, wwc1);
+      let wwc2 = u8_from_field_unsafe(to_field(wwo1) + to_field(wwc1a));
+      let (wwt2, wwo2) = u8_add(w16[1], w7[1]);
+      let (ww2, wwc2a) = u8_add(wwt2, wwc2);
+      let wwc3 = u8_from_field_unsafe(to_field(wwo2) + to_field(wwc2a));
+      let (wwt3, _x) = u8_add(w16[0], w7[0]);
+      let (ww3, _x) = u8_add(wwt3, wwc3);
+
+      let (wi0, wic1) = u8_add(ss0, ww0);
+      let (wit1, wio1) = u8_add(ss1, ww1);
+      let (wi1, wic1a) = u8_add(wit1, wic1);
+      let wic2 = u8_from_field_unsafe(to_field(wio1) + to_field(wic1a));
+      let (wit2, wio2) = u8_add(ss2, ww2);
+      let (wi2, wic2a) = u8_add(wit2, wic2);
+      let wic3 = u8_from_field_unsafe(to_field(wio2) + to_field(wic2a));
+      let (wit3, _x) = u8_add(ss3, ww3);
+      let (wi3, _x) = u8_add(wit3, wic3);
+      set(Wx, @i, [wi3, wi2, wi1, wi0])
+    );
+    let W = Wx;
 
     let state_new = fold(0 .. 64, state, |acc, @i|
       let e_0_bits = u8_bit_decomposition(acc[4][3]);
@@ -837,76 +891,23 @@ def sha256 := ⟦
       [[na3, na2, na1, na0], acc[0], acc[1], acc[2], [ne3, ne2, ne1, ne0], acc[4], acc[5], acc[6]]
     );
 
-    [
-      u32_be_add(state[0], state_new[0]),
-      u32_be_add(state[1], state_new[1]),
-      u32_be_add(state[2], state_new[2]),
-      u32_be_add(state[3], state_new[3]),
-      u32_be_add(state[4], state_new[4]),
-      u32_be_add(state[5], state_new[5]),
-      u32_be_add(state[6], state_new[6]),
-      u32_be_add(state[7], state_new[7])
-    ]
-  }
-
-  fn define_W_i(«W_i-2»: [U8; 4], «W_i-7»: [U8; 4], «W_i-15»: [U8; 4], «W_i-16»: [U8; 4]) -> [U8; 4] {
-    let [«W_i-15_b3», «W_i-15_b2», «W_i-15_b1», «W_i-15_b0»] = «W_i-15»;
-    let [«W_i-15_b0_0», «W_i-15_b0_1», «W_i-15_b0_2», «W_i-15_b0_3», «W_i-15_b0_4», «W_i-15_b0_5», «W_i-15_b0_6», «W_i-15_b0_7»] = u8_bit_decomposition(«W_i-15_b0»);
-    let [«W_i-15_b1_0», «W_i-15_b1_1», «W_i-15_b1_2», «W_i-15_b1_3», «W_i-15_b1_4», «W_i-15_b1_5», «W_i-15_b1_6», «W_i-15_b1_7»] = u8_bit_decomposition(«W_i-15_b1»);
-    let [«W_i-15_b2_0», «W_i-15_b2_1», «W_i-15_b2_2», «W_i-15_b2_3», «W_i-15_b2_4», «W_i-15_b2_5», «W_i-15_b2_6», «W_i-15_b2_7»] = u8_bit_decomposition(«W_i-15_b2»);
-    let [«W_i-15_b3_0», «W_i-15_b3_1», «W_i-15_b3_2», «W_i-15_b3_3», «W_i-15_b3_4», «W_i-15_b3_5», «W_i-15_b3_6», «W_i-15_b3_7»] = u8_bit_decomposition(«W_i-15_b3»);
-
-    let «W_i-15_rotr7» = [
-      u8_from_field_unsafe(«W_i-15_b3_7» + 2 * «W_i-15_b0_0» + 4 * «W_i-15_b0_1» + 8 * «W_i-15_b0_2» + 16 * «W_i-15_b0_3» + 32 * «W_i-15_b0_4» + 64 * «W_i-15_b0_5» + 128 * «W_i-15_b0_6»),
-      u8_from_field_unsafe(«W_i-15_b2_7» + 2 * «W_i-15_b3_0» + 4 * «W_i-15_b3_1» + 8 * «W_i-15_b3_2» + 16 * «W_i-15_b3_3» + 32 * «W_i-15_b3_4» + 64 * «W_i-15_b3_5» + 128 * «W_i-15_b3_6»),
-      u8_from_field_unsafe(«W_i-15_b1_7» + 2 * «W_i-15_b2_0» + 4 * «W_i-15_b2_1» + 8 * «W_i-15_b2_2» + 16 * «W_i-15_b2_3» + 32 * «W_i-15_b2_4» + 64 * «W_i-15_b2_5» + 128 * «W_i-15_b2_6»),
-      u8_from_field_unsafe(«W_i-15_b0_7» + 2 * «W_i-15_b1_0» + 4 * «W_i-15_b1_1» + 8 * «W_i-15_b1_2» + 16 * «W_i-15_b1_3» + 32 * «W_i-15_b1_4» + 64 * «W_i-15_b1_5» + 128 * «W_i-15_b1_6»)
-    ];
-
-    let «W_i-15_rotr18» = [
-      u8_from_field_unsafe(«W_i-15_b1_2» + 2 * «W_i-15_b1_3» + 4 * «W_i-15_b1_4» + 8 * «W_i-15_b1_5» + 16 * «W_i-15_b1_6» + 32 * «W_i-15_b1_7» + 64 * «W_i-15_b2_0» + 128 * «W_i-15_b2_1»),
-      u8_from_field_unsafe(«W_i-15_b0_2» + 2 * «W_i-15_b0_3» + 4 * «W_i-15_b0_4» + 8 * «W_i-15_b0_5» + 16 * «W_i-15_b0_6» + 32 * «W_i-15_b0_7» + 64 * «W_i-15_b1_0» + 128 * «W_i-15_b1_1»),
-      u8_from_field_unsafe(«W_i-15_b3_2» + 2 * «W_i-15_b3_3» + 4 * «W_i-15_b3_4» + 8 * «W_i-15_b3_5» + 16 * «W_i-15_b3_6» + 32 * «W_i-15_b3_7» + 64 * «W_i-15_b0_0» + 128 * «W_i-15_b0_1»),
-      u8_from_field_unsafe(«W_i-15_b2_2» + 2 * «W_i-15_b2_3» + 4 * «W_i-15_b2_4» + 8 * «W_i-15_b2_5» + 16 * «W_i-15_b2_6» + 32 * «W_i-15_b2_7» + 64 * «W_i-15_b3_0» + 128 * «W_i-15_b3_1»)
-    ];
-
-    let «W_i-15_shr3» = [
-      u8_from_field_unsafe(«W_i-15_b3_3» + 2 * «W_i-15_b3_4» + 4 * «W_i-15_b3_5» + 8 * «W_i-15_b3_6» + 16 * «W_i-15_b3_7»),
-      u8_from_field_unsafe(«W_i-15_b2_3» + 2 * «W_i-15_b2_4» + 4 * «W_i-15_b2_5» + 8 * «W_i-15_b2_6» + 16 * «W_i-15_b2_7» + 32 * «W_i-15_b3_0» + 64 * «W_i-15_b3_1» + 128 * «W_i-15_b3_2»),
-      u8_from_field_unsafe(«W_i-15_b1_3» + 2 * «W_i-15_b1_4» + 4 * «W_i-15_b1_5» + 8 * «W_i-15_b1_6» + 16 * «W_i-15_b1_7» + 32 * «W_i-15_b2_0» + 64 * «W_i-15_b2_1» + 128 * «W_i-15_b2_2»),
-      u8_from_field_unsafe(«W_i-15_b0_3» + 2 * «W_i-15_b0_4» + 4 * «W_i-15_b0_5» + 8 * «W_i-15_b0_6» + 16 * «W_i-15_b0_7» + 32 * «W_i-15_b1_0» + 64 * «W_i-15_b1_1» + 128 * «W_i-15_b1_2»)
-    ];
-
-    let [«W_i-2_b3», «W_i-2_b2», «W_i-2_b1», «W_i-2_b0»] = «W_i-2»;
-    let [«W_i-2_b0_0», «W_i-2_b0_1», «W_i-2_b0_2», «W_i-2_b0_3», «W_i-2_b0_4», «W_i-2_b0_5», «W_i-2_b0_6», «W_i-2_b0_7»] = u8_bit_decomposition(«W_i-2_b0»);
-    let [«W_i-2_b1_0», «W_i-2_b1_1», «W_i-2_b1_2», «W_i-2_b1_3», «W_i-2_b1_4», «W_i-2_b1_5», «W_i-2_b1_6», «W_i-2_b1_7»] = u8_bit_decomposition(«W_i-2_b1»);
-    let [«W_i-2_b2_0», «W_i-2_b2_1», «W_i-2_b2_2», «W_i-2_b2_3», «W_i-2_b2_4», «W_i-2_b2_5», «W_i-2_b2_6», «W_i-2_b2_7»] = u8_bit_decomposition(«W_i-2_b2»);
-    let [«W_i-2_b3_0», «W_i-2_b3_1», «W_i-2_b3_2», «W_i-2_b3_3», «W_i-2_b3_4», «W_i-2_b3_5», «W_i-2_b3_6», «W_i-2_b3_7»] = u8_bit_decomposition(«W_i-2_b3»);
-
-    let «W_i-2_rotr17» = [
-      u8_from_field_unsafe(«W_i-2_b1_1» + 2 * «W_i-2_b1_2» + 4 * «W_i-2_b1_3» + 8 * «W_i-2_b1_4» + 16 * «W_i-2_b1_5» + 32 * «W_i-2_b1_6» + 64 * «W_i-2_b1_7» + 128 * «W_i-2_b2_0»),
-      u8_from_field_unsafe(«W_i-2_b0_1» + 2 * «W_i-2_b0_2» + 4 * «W_i-2_b0_3» + 8 * «W_i-2_b0_4» + 16 * «W_i-2_b0_5» + 32 * «W_i-2_b0_6» + 64 * «W_i-2_b0_7» + 128 * «W_i-2_b1_0»),
-      u8_from_field_unsafe(«W_i-2_b3_1» + 2 * «W_i-2_b3_2» + 4 * «W_i-2_b3_3» + 8 * «W_i-2_b3_4» + 16 * «W_i-2_b3_5» + 32 * «W_i-2_b3_6» + 64 * «W_i-2_b3_7» + 128 * «W_i-2_b0_0»),
-      u8_from_field_unsafe(«W_i-2_b2_1» + 2 * «W_i-2_b2_2» + 4 * «W_i-2_b2_3» + 8 * «W_i-2_b2_4» + 16 * «W_i-2_b2_5» + 32 * «W_i-2_b2_6» + 64 * «W_i-2_b2_7» + 128 * «W_i-2_b3_0»)
-    ];
-
-    let «W_i-2_rotr19» = [
-      u8_from_field_unsafe(«W_i-2_b1_3» + 2 * «W_i-2_b1_4» + 4 * «W_i-2_b1_5» + 8 * «W_i-2_b1_6» + 16 * «W_i-2_b1_7» + 32 * «W_i-2_b2_0» + 64 * «W_i-2_b2_1» + 128 * «W_i-2_b2_2»),
-      u8_from_field_unsafe(«W_i-2_b0_3» + 2 * «W_i-2_b0_4» + 4 * «W_i-2_b0_5» + 8 * «W_i-2_b0_6» + 16 * «W_i-2_b0_7» + 32 * «W_i-2_b1_0» + 64 * «W_i-2_b1_1» + 128 * «W_i-2_b1_2»),
-      u8_from_field_unsafe(«W_i-2_b3_3» + 2 * «W_i-2_b3_4» + 4 * «W_i-2_b3_5» + 8 * «W_i-2_b3_6» + 16 * «W_i-2_b3_7» + 32 * «W_i-2_b0_0» + 64 * «W_i-2_b0_1» + 128 * «W_i-2_b0_2»),
-      u8_from_field_unsafe(«W_i-2_b2_3» + 2 * «W_i-2_b2_4» + 4 * «W_i-2_b2_5» + 8 * «W_i-2_b2_6» + 16 * «W_i-2_b2_7» + 32 * «W_i-2_b3_0» + 64 * «W_i-2_b3_1» + 128 * «W_i-2_b3_2»)
-    ];
-
-    let «W_i-2_shr10» = [
-      u8_from_field_unsafe(0),
-      u8_from_field_unsafe(«W_i-2_b3_2» + 2 * «W_i-2_b3_3» + 4 * «W_i-2_b3_4» + 8 * «W_i-2_b3_5» + 16 * «W_i-2_b3_6» + 32 * «W_i-2_b3_7»),
-      u8_from_field_unsafe(«W_i-2_b2_2» + 2 * «W_i-2_b2_3» + 4 * «W_i-2_b2_4» + 8 * «W_i-2_b2_5» + 16 * «W_i-2_b2_6» + 32 * «W_i-2_b2_7» + 64 * «W_i-2_b3_0» + 128 * «W_i-2_b3_1»),
-      u8_from_field_unsafe(«W_i-2_b1_2» + 2 * «W_i-2_b1_3» + 4 * «W_i-2_b1_4» + 8 * «W_i-2_b1_5» + 16 * «W_i-2_b1_6» + 32 * «W_i-2_b1_7» + 64 * «W_i-2_b2_0» + 128 * «W_i-2_b2_1»)
-    ];
-
-    let «W_i_s0» = u32_xor(«W_i-15_rotr7», u32_xor(«W_i-15_rotr18», «W_i-15_shr3»));
-    let «W_i_s1» = u32_xor(«W_i-2_rotr17», u32_xor(«W_i-2_rotr19», «W_i-2_shr10»));
-    u32_be_add(«W_i-16», u32_be_add(«W_i_s0», u32_be_add(«W_i-7», «W_i_s1»)))
+    -- Final Davies-Meyer state addition, inlined per word via the same
+    -- big-endian u8_add carry chains as the round body.
+    let fs = fold(0 .. 8, [[0u8; 4]; 8], |fs, @j|
+      let sw = state[@j];
+      let nw = state_new[@j];
+      let (f0, fc1) = u8_add(sw[3], nw[3]);
+      let (ft1, fo1) = u8_add(sw[2], nw[2]);
+      let (f1, fc1a) = u8_add(ft1, fc1);
+      let fc2 = u8_from_field_unsafe(to_field(fo1) + to_field(fc1a));
+      let (ft2, fo2) = u8_add(sw[1], nw[1]);
+      let (f2, fc2a) = u8_add(ft2, fc2);
+      let fc3 = u8_from_field_unsafe(to_field(fo2) + to_field(fc2a));
+      let (ft3, _x) = u8_add(sw[0], nw[0]);
+      let (f3, _x) = u8_add(ft3, fc3);
+      set(fs, @j, [f3, f2, f1, f0])
+    );
+    fs
   }
 ⟧
 

From 29e85daf108720581cc47a7134a228e49282ea6c Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Mon, 13 Jul 2026 14:48:19 +0000
Subject: [PATCH 04/22] Aiur: inlined function calls (`@fn(args)`)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace `Source.Term.app`'s `unconstrained : Bool` with a `CallMode`
(normal | unconstrained | inlined). `@fn(args)` marks an inlined call:
`Toplevel.inlineCalls`, run first in `compile`, splices the callee's
body into the caller — each input Local bound to its argument via a
let, the (recursively inline-expanded) body as the value. Inlining is
forbidden for callees that are transitively inline-recursive.

An inlined call compiles to no separate circuit and no call interface
(no lookup, no output columns): the callee's work joins the caller's
straight-line circuit. This lets a hot inner routine be written once
and expanded into a single wide circuit, instead of paying the
per-call state-rematerialization and the taller callee-circuit height.

The mode only exists in the Source stage — `inlineCalls` eliminates
`.inlined` before typechecking, and Check maps normal->false /
unconstrained->true into the existing downstream bool. Interpreters
match the mode as `_` (an inlined call executes identically to a
normal one), so evaluation is unchanged.

The pass expands bottom-up over the inline-call DAG (Kahn topo order),
so it is fuel-free and total. At each inline site the callee's inputs
and body are alpha-renamed to fresh `inl#N` locals before argument
binding, so nested `@`-calls cannot capture caller bindings; spliced
let-chains are hoisted out of strict argument positions (array
elements, operator operands, app arguments), which lowering would
otherwise reject. Also drops a `simp` arg in `compile_stages_of_ok`
that the final pipeline shape no longer needs.
---
 Ix/Aiur/Compiler.lean       |  45 ++--
 Ix/Aiur/Compiler/Check.lean |   9 +-
 Ix/Aiur/Meta.lean           |  30 ++-
 Ix/Aiur/Stages/Source.lean  | 486 +++++++++++++++++++++++++++++++++++-
 4 files changed, 537 insertions(+), 33 deletions(-)

diff --git a/Ix/Aiur/Compiler.lean b/Ix/Aiur/Compiler.lean
index ae250399..d8526663 100644
--- a/Ix/Aiur/Compiler.lean
+++ b/Ix/Aiur/Compiler.lean
@@ -112,6 +112,7 @@ def Bytecode.Toplevel.needsCircuit (t : Bytecode.Toplevel) : Array Bool := Id.ru
 
 /-- Full compilation pipeline. -/
 def Source.Toplevel.compile (t : Source.Toplevel) : Except String CompiledToplevel := do
+  let t ← t.inlineCalls
   let typedDecls ← t.checkAndSimplify.mapError toString
   let concDecls ← typedDecls.concretize.mapError toString
   let (bytecodeRaw, preNameMap) ← concDecls.toBytecode
@@ -129,13 +130,14 @@ def Source.Toplevel.compile (t : Source.Toplevel) : Except String CompiledToplev
 `needsCircuit`, the field-setter `mapIdx`, the name-map `fold`, and the
 terminating `pure` — are all total). -/
 theorem Source.Toplevel.compile_ok_of_stages
-    {t : Source.Toplevel} {typedDecls concDecls bytecodeRaw preNameMap}
-    (hts : t.checkAndSimplify = .ok typedDecls)
+    {t inlined : Source.Toplevel} {typedDecls concDecls bytecodeRaw preNameMap}
+    (hinline : t.inlineCalls = .ok inlined)
+    (hts : inlined.checkAndSimplify = .ok typedDecls)
     (hconc : typedDecls.concretize = .ok concDecls)
     (hbc : concDecls.toBytecode = .ok (bytecodeRaw, preNameMap)) :
     ∃ ct, t.compile = .ok ct := by
-  simp only [Source.Toplevel.compile, hts, hconc, hbc, Except.mapError, bind,
-             Except.bind, pure, Except.pure]
+  simp only [Source.Toplevel.compile, hinline, hts, hconc, hbc, Except.mapError,
+             bind, Except.bind, pure, Except.pure]
   exact ⟨_, rfl⟩
 
 /-- Inverse of `compile_ok_of_stages`: unpack a successful `compile` into
@@ -144,27 +146,28 @@ lemmas through the composition. -/
 theorem Source.Toplevel.compile_stages_of_ok
     {t : Source.Toplevel} {ct : CompiledToplevel}
     (_hct : t.compile = .ok ct) :
-    ∃ typedDecls concDecls bytecodeRaw preNameMap,
-      t.checkAndSimplify = .ok typedDecls ∧
+    ∃ inlined typedDecls concDecls bytecodeRaw preNameMap,
+      t.inlineCalls = .ok inlined ∧
+      inlined.checkAndSimplify = .ok typedDecls ∧
       typedDecls.concretize = .ok concDecls ∧
       concDecls.toBytecode = .ok (bytecodeRaw, preNameMap) := by
   -- Case on each stage result; `mapError` on `.ok` is definitionally `.ok`.
-  cases hts : t.checkAndSimplify with
-  | error e => simp [Source.Toplevel.compile, hts, bind, Except.bind, Except.mapError] at _hct
-  | ok typedDecls =>
-    cases hconc : typedDecls.concretize with
-    | error e =>
-      simp [Source.Toplevel.compile, hts, hconc, bind, Except.bind, Except.mapError] at _hct
-    | ok concDecls =>
-      cases hbc : concDecls.toBytecode with
+  cases hinline : t.inlineCalls with
+  | error e => simp [Source.Toplevel.compile, hinline, bind, Except.bind] at _hct
+  | ok inlined =>
+    cases hts : inlined.checkAndSimplify with
+    | error e => simp [Source.Toplevel.compile, hinline, hts, bind, Except.bind, Except.mapError] at _hct
+    | ok typedDecls =>
+      cases hconc : typedDecls.concretize with
       | error e =>
-        simp [Source.Toplevel.compile, hts, hconc, hbc, bind, Except.bind, Except.mapError] at _hct
-      | ok bc =>
-        obtain ⟨bytecodeRaw, preNameMap⟩ := bc
-        -- `checkAndSimplify`/`concretize` are unfolded; `toBytecode` is not
-        -- (private module), so the first two equalities reduce to `rfl` but
-        -- the third still mentions `concDecls.toBytecode` — supply `hbc`.
-        exact ⟨typedDecls, concDecls, bytecodeRaw, preNameMap, rfl, hconc, hbc⟩
+        simp [Source.Toplevel.compile, hinline, hts, hconc, bind, Except.bind, Except.mapError] at _hct
+      | ok concDecls =>
+        cases hbc : concDecls.toBytecode with
+        | error e =>
+          simp [Source.Toplevel.compile, hinline, hts, hconc, hbc, bind, Except.bind, Except.mapError] at _hct
+        | ok bc =>
+          obtain ⟨bytecodeRaw, preNameMap⟩ := bc
+          exact ⟨inlined, typedDecls, concDecls, bytecodeRaw, preNameMap, rfl, hts, hconc, hbc⟩
 
 -- Compile post-conditions moved to `Proofs/StructCompatible.lean`.
 
diff --git a/Ix/Aiur/Compiler/Check.lean b/Ix/Aiur/Compiler/Check.lean
index a42a4dd4..2066a8b4 100644
--- a/Ix/Aiur/Compiler/Check.lean
+++ b/Ix/Aiur/Compiler/Check.lean
@@ -622,7 +622,14 @@ def inferTerm (t : Term) : CheckM Typed.Term := match t with
     match typOpt with
     | some (typ, escapes) => pure (Typed.Term.match typ escapes term' branches')
     | none => throw .emptyMatch
-  | .app func args u => do
+  | .app func args mode => do
+    -- `.inlined` is eliminated by `Toplevel.inlineCalls` before checking;
+    -- reaching it here means the pass was skipped. Downstream stages carry
+    -- only the unconstrained flag.
+    let u : Bool ← match mode with
+      | .normal => pure false
+      | .unconstrained => pure true
+      | .inlined => throw (.cannotApply func)
     let ctx ← read
     -- Local function lookup (only for unqualified names); returns
     -- `some (.ok …)` on hit, `some (.error …)` on wrong-type local, `none` to
diff --git a/Ix/Aiur/Meta.lean b/Ix/Aiur/Meta.lean
index c215e69c..4485453b 100644
--- a/Ix/Aiur/Meta.lean
+++ b/Ix/Aiur/Meta.lean
@@ -156,6 +156,10 @@ syntax ("." noWs)? ident "(" ")"                                              :
 syntax ("." noWs)? ident "(" aiur_trm (", " aiur_trm)* ")"                  : aiur_trm
 syntax "#" noWs ("." noWs)? ident "(" ")"                                     : aiur_trm
 syntax "#" noWs ("." noWs)? ident "(" aiur_trm (", " aiur_trm)* ")"         : aiur_trm
+-- Inlined call: `@fn(args)` splices `fn`'s body into the caller at compile
+-- time (no separate circuit). Callee must not be inline-recursive.
+syntax "@" noWs ("." noWs)? ident "(" ")"                                     : aiur_trm
+syntax "@" noWs ("." noWs)? ident "(" aiur_trm (", " aiur_trm)* ")"         : aiur_trm
 syntax ident "‹" aiur_typ (", " aiur_typ)* "›" "(" ")"                      : aiur_trm
 syntax ident "‹" aiur_typ (", " aiur_typ)* "›" "(" aiur_trm
        (", " aiur_trm)* ")"                                                  : aiur_trm
@@ -267,16 +271,22 @@ partial def elabTrm : ElabStxCat `aiur_trm
     | .str .anonymous _ => pure ()
     | _ => logWarningAt f "empty parentheses are not needed; use the name without parentheses"
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, toExpr false]
+    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.normal]
   | `(aiur_trm| $[.]?$f:ident ($a:aiur_trm $[, $as:aiur_trm]*)) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, toExpr false]
+    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.normal]
   | `(aiur_trm| #$[.]?$f:ident()) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, toExpr true]
+    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.unconstrained]
   | `(aiur_trm| #$[.]?$f:ident($a:aiur_trm $[, $as:aiur_trm]*)) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, toExpr true]
+    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.unconstrained]
+  | `(aiur_trm| @$[.]?$f:ident()) => do
+    let g ← mkAppM ``Global.mk #[toExpr f.getId]
+    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.inlined]
+  | `(aiur_trm| @$[.]?$f:ident($a:aiur_trm $[, $as:aiur_trm]*)) => do
+    let g ← mkAppM ``Global.mk #[toExpr f.getId]
+    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.inlined]
   | `(aiur_trm| $a:aiur_trm + $b:aiur_trm) => do
     mkAppM ``Source.Term.add #[← elabTrm a, ← elabTrm b]
   | `(aiur_trm| $a:aiur_trm - $b:aiur_trm) => do
@@ -356,29 +366,29 @@ partial def elabTrm : ElabStxCat `aiur_trm
   -- Template function calls: explicit type args are dropped (inferred)
   | `(aiur_trm| $f:ident‹$_:aiur_typ $[, $_:aiur_typ]*›()) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, toExpr false]
+    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.normal]
   | `(aiur_trm| $f:ident‹$_:aiur_typ $[, $_:aiur_typ]*›
                  ($a:aiur_trm $[, $as:aiur_trm]*)) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, toExpr false]
+    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.normal]
   | `(aiur_trm| #$f:ident‹$_:aiur_typ $[, $_:aiur_typ]*›()) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, toExpr true]
+    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.unconstrained]
   | `(aiur_trm| #$f:ident‹$_:aiur_typ $[, $_:aiur_typ]*›
                  ($a:aiur_trm $[, $as:aiur_trm]*)) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, toExpr true]
+    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.unconstrained]
   -- Template constructor calls
   | `(aiur_trm| $tmpl:ident‹$_:aiur_typ $[, $_:aiur_typ]*›.$ctor:ident()) => do
     logWarningAt ctor "empty parentheses are not needed; use the name without parentheses"
     let name := tmpl.getId ++ ctor.getId
     let g ← mkAppM ``Global.mk #[toExpr name]
-    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, toExpr false]
+    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.normal]
   | `(aiur_trm| $tmpl:ident‹$_:aiur_typ $[, $_:aiur_typ]*›.$ctor:ident
                  ($a:aiur_trm $[, $as:aiur_trm]*)) => do
     let name := tmpl.getId ++ ctor.getId
     let g ← mkAppM ``Global.mk #[toExpr name]
-    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, toExpr false]
+    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.normal]
   | `(aiur_trm| fold($i .. $j, $init, |$acc, @$v| $body)) => do
     let i := i.getNat
     let j := j.getNat
diff --git a/Ix/Aiur/Stages/Source.lean b/Ix/Aiur/Stages/Source.lean
index 1e548b2b..7f96f4f8 100644
--- a/Ix/Aiur/Stages/Source.lean
+++ b/Ix/Aiur/Stages/Source.lean
@@ -374,6 +374,21 @@ inductive Pattern
 
 namespace Source
 
+/-- How a function application is compiled.
+* `normal` — a constrained circuit call (its own circuit, a lookup, and
+  output columns at the call site).
+* `unconstrained` — a call whose callee is trusted (no lookup / circuit
+  constraint); the old `unconstrained := true`.
+* `inlined` — the callee's body is spliced into the caller at compile
+  time (no separate circuit, no interface columns). Eliminated by
+  `Toplevel.inlineCalls` before typechecking; forbidden for callees that
+  are (transitively) inline-recursive. -/
+inductive CallMode
+  | normal
+  | unconstrained
+  | inlined
+  deriving Repr, BEq, Hashable, Inhabited, DecidableEq
+
 /-- Stage 1 term language. `tuple` and `array` are direct constructors (no `Data`
 mutual child); cf. `Ix/Aiur/Term.lean` which nested them under `.data`. -/
 inductive Term
@@ -386,7 +401,7 @@ inductive Term
   | ret : Term → Term
   | let : Pattern → Term → Term → Term
   | match : Term → List (Pattern × Term) → Term
-  | app : Global → List Term → (unconstrained : Bool) → Term
+  | app : Global → List Term → (mode : CallMode) → Term
   | add : Term → Term → Term
   | sub : Term → Term → Term
   | mul : Term → Term → Term
@@ -539,6 +554,475 @@ where
         result := result.push item
     pure (globals, result)
 
+/-- Rename every local bound in a pattern to a fresh `.str "inl#N"` name,
+extending `subst` for the pattern's scope and advancing the fresh counter.
+-/
+def Pattern.freshen (cnt : Nat) (subst : Std.HashMap Local Local) :
+    Pattern → Nat × Std.HashMap Local Local × Pattern
+  | .var x =>
+    let x' : Local := .str s!"inl#{cnt}"
+    (cnt + 1, subst.insert x x', .var x')
+  | .wildcard => (cnt, subst, .wildcard)
+  | .field g => (cnt, subst, .field g)
+  | .ref g ps =>
+    let (cnt, subst, ps') := ps.attach.foldl (init := (cnt, subst, ([] : List Pattern)))
+      fun (cnt, subst, acc) ⟨p, _⟩ =>
+        let (cnt, subst, p') := Pattern.freshen cnt subst p
+        (cnt, subst, acc ++ [p'])
+    (cnt, subst, .ref g ps')
+  | .tuple ps =>
+    let (cnt, subst, ps') := ps.attach.foldl (init := (cnt, subst, (#[] : Array Pattern)))
+      fun (cnt, subst, acc) ⟨p, _⟩ =>
+        let (cnt, subst, p') := Pattern.freshen cnt subst p
+        (cnt, subst, acc.push p')
+    (cnt, subst, .tuple ps')
+  | .array ps =>
+    let (cnt, subst, ps') := ps.attach.foldl (init := (cnt, subst, (#[] : Array Pattern)))
+      fun (cnt, subst, acc) ⟨p, _⟩ =>
+        let (cnt, subst, p') := Pattern.freshen cnt subst p
+        (cnt, subst, acc.push p')
+    (cnt, subst, .array ps')
+  | .or p q =>
+    let (cnt, subst, p') := Pattern.freshen cnt subst p
+    let (cnt, subst, q') := Pattern.freshen cnt subst q
+    (cnt, subst, .or p' q')
+  | .pointer p =>
+    let (cnt, subst, p') := Pattern.freshen cnt subst p
+    (cnt, subst, .pointer p')
+termination_by p => sizeOf p
+decreasing_by
+  all_goals first
+    | decreasing_tactic
+    | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+    | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+
+/-- Consistently α-rename the locals bound inside `t` to fresh names,
+following `subst` for the currently-renamed variables. Used before
+splicing an inlined body so its locals cannot collide with the caller's
+(the `Simple` pass floats nested `let`s outward, which would otherwise
+capture reused names). Only bound occurrences are rewritten; free
+variables that are the callee's inputs are handled by `subst` seeded at
+the call site. -/
+def Term.freshen (cnt : Nat) (subst : Std.HashMap Local Local) :
+    Term → Nat × Term :=
+  fun t =>
+  match t with
+  | .var x => (cnt, .var (subst.getD x x))
+  | .unit | .ref _ | .field _ | .u8Lit _ => (cnt, t)
+  | .let p v b =>
+    let (cnt, v') := Term.freshen cnt subst v
+    let (cnt, subst', p') := Pattern.freshen cnt subst p
+    let (cnt, b') := Term.freshen cnt subst' b
+    (cnt, .let p' v' b')
+  | .match s arms =>
+    let (cnt, s') := Term.freshen cnt subst s
+    let (cnt, arms') := arms.attach.foldl (init := (cnt, ([] : List (Pattern × Term))))
+      fun (cnt, acc) ⟨(p, a), _⟩ =>
+        let (cnt, subst', p') := Pattern.freshen cnt subst p
+        let (cnt, a') := Term.freshen cnt subst' a
+        (cnt, acc ++ [(p', a')])
+    (cnt, .match s' arms')
+  | .tuple ts =>
+    let (cnt, ts') := ts.attach.foldl (init := (cnt, #[])) fun (cnt, acc) ⟨x, _⟩ =>
+      let (cnt, x') := Term.freshen cnt subst x; (cnt, acc.push x')
+    (cnt, .tuple ts')
+  | .array ts =>
+    let (cnt, ts') := ts.attach.foldl (init := (cnt, #[])) fun (cnt, acc) ⟨x, _⟩ =>
+      let (cnt, x') := Term.freshen cnt subst x; (cnt, acc.push x')
+    (cnt, .array ts')
+  | .app g args mode =>
+    let (cnt, args') := args.attach.foldl (init := (cnt, ([] : List Term))) fun (cnt, acc) ⟨x, _⟩ =>
+      let (cnt, x') := Term.freshen cnt subst x; (cnt, acc ++ [x'])
+    (cnt, .app g args' mode)
+  | .ret a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .ret a')
+  | .add a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .add a' b')
+  | .sub a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .sub a' b')
+  | .mul a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .mul a' b')
+  | .eqZero a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .eqZero a')
+  | .proj a n => let (cnt, a') := Term.freshen cnt subst a; (cnt, .proj a' n)
+  | .get a n => let (cnt, a') := Term.freshen cnt subst a; (cnt, .get a' n)
+  | .slice a i j => let (cnt, a') := Term.freshen cnt subst a; (cnt, .slice a' i j)
+  | .set a n v => let (cnt, a') := Term.freshen cnt subst a; let (cnt, v') := Term.freshen cnt subst v; (cnt, .set a' n v')
+  | .store a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .store a')
+  | .load a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .load a')
+  | .ptrVal a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .ptrVal a')
+  | .ann τ a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .ann τ a')
+  | .assertEq a b c =>
+    let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; let (cnt, c') := Term.freshen cnt subst c
+    (cnt, .assertEq a' b' c')
+  | .ioGetInfo c k => let (cnt, c') := Term.freshen cnt subst c; let (cnt, k') := Term.freshen cnt subst k; (cnt, .ioGetInfo c' k')
+  | .ioSetInfo c k i l rv =>
+    let (cnt, c') := Term.freshen cnt subst c; let (cnt, k') := Term.freshen cnt subst k; let (cnt, i') := Term.freshen cnt subst i
+    let (cnt, l') := Term.freshen cnt subst l; let (cnt, rv') := Term.freshen cnt subst rv
+    (cnt, .ioSetInfo c' k' i' l' rv')
+  | .ioRead c i n => let (cnt, c') := Term.freshen cnt subst c; let (cnt, i') := Term.freshen cnt subst i; (cnt, .ioRead c' i' n)
+  | .ioWrite c d rv =>
+    let (cnt, c') := Term.freshen cnt subst c; let (cnt, d') := Term.freshen cnt subst d; let (cnt, rv') := Term.freshen cnt subst rv
+    (cnt, .ioWrite c' d' rv')
+  | .u8BitDecomposition a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8BitDecomposition a')
+  | .u8ShiftLeft a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8ShiftLeft a')
+  | .u8ShiftRight a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8ShiftRight a')
+  | .u8Xor a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Xor a' b')
+  | .u8Add a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Add a' b')
+  | .u8Mul a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Mul a' b')
+  | .u8Sub a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Sub a' b')
+  | .u8And a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8And a' b')
+  | .u8Or a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Or a' b')
+  | .u8LessThan a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8LessThan a' b')
+  | .u32LessThan a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u32LessThan a' b')
+  | .u8ChainRotr7 a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8ChainRotr7 a' b')
+  | .u8ChainRotr4 a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8ChainRotr4 a' b')
+  | .unconstrainedBigUintDivMod a b =>
+    let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .unconstrainedBigUintDivMod a' b')
+  | .u8RangeCheck a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8RangeCheck a' b')
+  | .toField a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .toField a')
+  | .u8FromFieldUnsafe a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8FromFieldUnsafe a')
+  | .debug s o a =>
+    let (cnt, o') := match o with
+      | none => (cnt, none)
+      | some x => let (cnt, x') := Term.freshen cnt subst x; (cnt, some x')
+    let (cnt, a') := Term.freshen cnt subst a
+    (cnt, .debug s o' a')
+termination_by t => sizeOf t
+decreasing_by
+  all_goals first
+    | decreasing_tactic
+    | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+    | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+
+/-- Every `.inlined` call site in `t`, as `(callee, argCount)` pairs. Drives
+both validation (callee exists, arity matches) and the inline-dependency
+graph the bottom-up expansion is ordered by. -/
+def Term.inlineCallSites : Term → List (Global × Nat)
+  | .app g args .inlined =>
+    args.attach.foldl (fun acc ⟨a, _⟩ => acc ++ a.inlineCallSites) [(g, args.length)]
+  | .app _ args _ =>
+    args.attach.foldl (fun acc ⟨a, _⟩ => acc ++ a.inlineCallSites) []
+  | .unit | .var _ | .ref _ | .field _ | .u8Lit _ => []
+  | .tuple ts | .array ts =>
+    ts.attach.foldl (fun acc ⟨a, _⟩ => acc ++ a.inlineCallSites) []
+  | .match s arms =>
+    arms.attach.foldl (fun acc ⟨(_, a), _⟩ => acc ++ a.inlineCallSites) s.inlineCallSites
+  | .let _ v b => v.inlineCallSites ++ b.inlineCallSites
+  | .add a b | .sub a b | .mul a b | .set a _ b
+  | .u8Xor a b | .u8Add a b | .u8Mul a b | .u8Sub a b | .u8And a b | .u8Or a b
+  | .u8LessThan a b | .u32LessThan a b | .u8ChainRotr7 a b | .u8ChainRotr4 a b
+  | .unconstrainedBigUintDivMod a b | .u8RangeCheck a b | .ioGetInfo a b =>
+    a.inlineCallSites ++ b.inlineCallSites
+  | .assertEq a b c | .ioWrite a b c => a.inlineCallSites ++ b.inlineCallSites ++ c.inlineCallSites
+  | .ioSetInfo c k i l rv =>
+    c.inlineCallSites ++ k.inlineCallSites ++ i.inlineCallSites ++ l.inlineCallSites ++ rv.inlineCallSites
+  | .ioRead a b _ => a.inlineCallSites ++ b.inlineCallSites
+  | .ret a | .eqZero a | .proj a _ | .get a _ | .slice a _ _ | .store a | .load a
+  | .ptrVal a | .ann _ a | .u8BitDecomposition a | .u8ShiftLeft a | .u8ShiftRight a
+  | .toField a | .u8FromFieldUnsafe a => a.inlineCallSites
+  | .debug _ o a => (match o with | none => [] | some x => x.inlineCallSites) ++ a.inlineCallSites
+termination_by t => sizeOf t
+decreasing_by
+  all_goals first
+    | decreasing_tactic
+    | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+    | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+
+/-- Structurally splice every `.app g args .inlined` in `t`, given `done`,
+which maps each already-expanded callee to its input locals and its (already
+inline-free) body. At an inline site the callee's inputs and body are
+α-renamed to fresh `inl#N` names (`Term.freshen`, seeded with the inputs),
+then each fresh input is bound to its argument via a `let`. Freshening the
+inputs BEFORE binding the arguments is essential: arguments are caller terms,
+so a fresh input name cannot shadow a caller local an argument references (nor
+collide across copies).
+
+Bottom-up ordering (see `Toplevel.inlineCalls`) guarantees `done[g]` is
+already inline-free, so the spliced body is NOT re-traversed — the recursion
+is purely structural on `t` and needs no fuel. `cnt` threads the fresh-name
+counter. If `done` lacks `g` the site is left untouched; the ordering makes
+that unreachable. -/
+def Term.expandOnce (done : Std.HashMap Global (List Local × Term)) (cnt : Nat) :
+    Term → Nat × Term := fun t => match t with
+  | .app g args .inlined =>
+    let (cnt, args') := args.attach.foldl (init := (cnt, ([] : List Term)))
+      fun (cnt, acc) ⟨a, _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc ++ [a'])
+    match done[g]? with
+    | none => (cnt, .app g args' .inlined)
+    | some (ins, body) =>
+      let (cnt, subst, freshInputs) := ins.foldl
+        (init := (cnt, (∅ : Std.HashMap Local Local), ([] : List Local)))
+        fun (cnt, subst, acc) inp =>
+          let inp' : Local := .str s!"inl#{cnt}"
+          (cnt + 1, subst.insert inp inp', acc ++ [inp'])
+      let (cnt, freshBody) := Term.freshen cnt subst body
+      (cnt, (freshInputs.zip args').foldr
+        (fun (input, arg) acc => Term.let (.var input) arg acc) freshBody)
+  | .app g args mode =>
+    let (cnt, args') := args.attach.foldl (init := (cnt, ([] : List Term)))
+      fun (cnt, acc) ⟨a, _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc ++ [a'])
+    (cnt, .app g args' mode)
+  | .unit | .var _ | .ref _ | .field _ | .u8Lit _ => (cnt, t)
+  | .tuple ts =>
+    let (cnt, ts') := ts.attach.foldl (init := (cnt, #[]))
+      fun (cnt, acc) ⟨a, _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc.push a')
+    (cnt, .tuple ts')
+  | .array ts =>
+    let (cnt, ts') := ts.attach.foldl (init := (cnt, #[]))
+      fun (cnt, acc) ⟨a, _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc.push a')
+    (cnt, .array ts')
+  | .match s arms =>
+    let (cnt, s') := Term.expandOnce done cnt s
+    let (cnt, arms') := arms.attach.foldl (init := (cnt, ([] : List (Pattern × Term))))
+      fun (cnt, acc) ⟨(p, a), _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc ++ [(p, a')])
+    (cnt, .match s' arms')
+  | .let p v b =>
+    let (cnt, v') := Term.expandOnce done cnt v
+    let (cnt, b') := Term.expandOnce done cnt b
+    (cnt, .let p v' b')
+  | .ret a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .ret a')
+  | .add a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .add a' b')
+  | .sub a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .sub a' b')
+  | .mul a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .mul a' b')
+  | .eqZero a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .eqZero a')
+  | .proj a n => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .proj a' n)
+  | .get a n => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .get a' n)
+  | .slice a i j => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .slice a' i j)
+  | .set a n v => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, v') := Term.expandOnce done cnt v; (cnt, .set a' n v')
+  | .store a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .store a')
+  | .load a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .load a')
+  | .ptrVal a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .ptrVal a')
+  | .ann τ a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .ann τ a')
+  | .assertEq a b c =>
+    let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b
+    let (cnt, c') := Term.expandOnce done cnt c; (cnt, .assertEq a' b' c')
+  | .ioGetInfo c k => let (cnt, c') := Term.expandOnce done cnt c; let (cnt, k') := Term.expandOnce done cnt k; (cnt, .ioGetInfo c' k')
+  | .ioSetInfo c k i l rv =>
+    let (cnt, c') := Term.expandOnce done cnt c; let (cnt, k') := Term.expandOnce done cnt k
+    let (cnt, i') := Term.expandOnce done cnt i; let (cnt, l') := Term.expandOnce done cnt l
+    let (cnt, rv') := Term.expandOnce done cnt rv; (cnt, .ioSetInfo c' k' i' l' rv')
+  | .ioRead c i n => let (cnt, c') := Term.expandOnce done cnt c; let (cnt, i') := Term.expandOnce done cnt i; (cnt, .ioRead c' i' n)
+  | .ioWrite c d rv =>
+    let (cnt, c') := Term.expandOnce done cnt c; let (cnt, d') := Term.expandOnce done cnt d
+    let (cnt, rv') := Term.expandOnce done cnt rv; (cnt, .ioWrite c' d' rv')
+  | .u8BitDecomposition a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8BitDecomposition a')
+  | .u8ShiftLeft a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8ShiftLeft a')
+  | .u8ShiftRight a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8ShiftRight a')
+  | .u8Xor a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Xor a' b')
+  | .u8Add a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Add a' b')
+  | .u8Mul a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Mul a' b')
+  | .u8Sub a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Sub a' b')
+  | .u8And a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8And a' b')
+  | .u8Or a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Or a' b')
+  | .u8LessThan a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8LessThan a' b')
+  | .u32LessThan a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u32LessThan a' b')
+  | .u8ChainRotr7 a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8ChainRotr7 a' b')
+  | .u8ChainRotr4 a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8ChainRotr4 a' b')
+  | .unconstrainedBigUintDivMod a b =>
+    let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .unconstrainedBigUintDivMod a' b')
+  | .u8RangeCheck a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8RangeCheck a' b')
+  | .toField a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .toField a')
+  | .u8FromFieldUnsafe a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8FromFieldUnsafe a')
+  | .debug s o a =>
+    let (cnt, o') := match o with
+      | none => (cnt, none)
+      | some x => let (cnt, x') := Term.expandOnce done cnt x; (cnt, some x')
+    let (cnt, a') := Term.expandOnce done cnt a
+    (cnt, .debug s o' a')
+termination_by t => sizeOf t
+decreasing_by
+  all_goals first
+    | decreasing_tactic
+    | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+    | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+
+/-- Peel the leading `let` bindings off a term: returns the binding frames
+(outermost first) and the non-`let` core. -/
+def Term.peelLets : Term → List (Pattern × Term) × Term
+  | .let p v b => let (fs, c) := Term.peelLets b; ((p, v) :: fs, c)
+  | t => ([], t)
+
+/-- Wrap `body` in a chain of `let` frames (first frame outermost). -/
+def Term.wrapLets : List (Pattern × Term) → Term → Term
+  | [], body => body
+  | (p, v) :: fs, body => .let p v (Term.wrapLets fs body)
+
+/-- Peel leading lets off each of `ts` (already hoisted), collecting the
+frames left-to-right so evaluation order is preserved, and returning the
+frame chain plus the cores. -/
+def Term.peelListLets (ts : List Term) : List (Pattern × Term) × List Term :=
+  ts.foldr
+    (fun t (fs, cs) => let (f, c) := Term.peelLets t; (f ++ fs, c :: cs))
+    ([], [])
+
+def Term.peelArrayLets (ts : Array Term) : List (Pattern × Term) × Array Term :=
+  let (fs, cs) := Term.peelListLets ts.toList
+  (fs, cs.toArray)
+
+/-- Hoist every `let`-chain out of a strict argument position into a
+wrapping `let`. Inlining splices a callee body (a `let`-chain ending in a
+value) wherever the `@`-call appeared; in a `let`-RHS or tail position the
+`Simple` pass already floats those lets outward, but in an argument
+position (a `set`/array element, an operator operand, …) they would stay
+nested, which the lowering cannot handle. This normalizes all such
+positions. `let`-RHS, `match` arm bodies, and `ret`/`debug` continuations
+are already handled downstream, so their lets are left in place. -/
+def Term.hoistLets : Term → Term :=
+  fun t =>
+  -- Hoist a construct's argument terms: peel each arg's lets and wrap.
+  match t with
+  | .unit | .var _ | .ref _ | .field _ | .u8Lit _ => t
+  | .let p v b => .let p (Term.hoistLets v) (Term.hoistLets b)
+  | .match s arms =>
+    let (fs, sc) := Term.peelLets (Term.hoistLets s)
+    Term.wrapLets fs (.match sc (arms.attach.map fun ⟨(p, a), _⟩ => (p, Term.hoistLets a)))
+  | .ret a => .ret (Term.hoistLets a)
+  | .debug s o a =>
+    .debug s (match o with | none => none | some x => some (Term.hoistLets x)) (Term.hoistLets a)
+  | .tuple ts =>
+    let (fs, cs) := Term.peelArrayLets (ts.attach.map fun ⟨x, _⟩ => Term.hoistLets x)
+    Term.wrapLets fs (.tuple cs)
+  | .array ts =>
+    let (fs, cs) := Term.peelArrayLets (ts.attach.map fun ⟨x, _⟩ => Term.hoistLets x)
+    Term.wrapLets fs (.array cs)
+  | .app g args mode =>
+    let (fs, cs) := Term.peelListLets (args.attach.map fun ⟨x, _⟩ => Term.hoistLets x)
+    Term.wrapLets fs (.app g cs mode)
+  | .assertEq a b c =>
+    let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b, Term.hoistLets c]
+    match cs with
+    | [a, b, c] => Term.wrapLets fs (.assertEq a b c)
+    | _ => t
+  | .ioSetInfo a b c d e =>
+    let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b, Term.hoistLets c, Term.hoistLets d, Term.hoistLets e]
+    match cs with
+    | [a, b, c, d, e] => Term.wrapLets fs (.ioSetInfo a b c d e)
+    | _ => t
+  | .ioWrite a b c =>
+    let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b, Term.hoistLets c]
+    match cs with
+    | [a, b, c] => Term.wrapLets fs (.ioWrite a b c)
+    | _ => t
+  | .ioGetInfo a b =>
+    let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+    match cs with | [a, b] => Term.wrapLets fs (.ioGetInfo a b) | _ => t
+  | .ioRead a b n =>
+    let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+    match cs with | [a, b] => Term.wrapLets fs (.ioRead a b n) | _ => t
+  | .add a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                match cs with | [a, b] => Term.wrapLets fs (.add a b) | _ => t
+  | .sub a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                match cs with | [a, b] => Term.wrapLets fs (.sub a b) | _ => t
+  | .mul a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                match cs with | [a, b] => Term.wrapLets fs (.mul a b) | _ => t
+  | .eqZero a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.eqZero c)
+  | .proj a n => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.proj c n)
+  | .get a n => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.get c n)
+  | .slice a i j => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.slice c i j)
+  | .set a n v =>
+    let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets v]
+    match cs with | [a, v] => Term.wrapLets fs (.set a n v) | _ => t
+  | .store a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.store c)
+  | .load a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.load c)
+  | .ptrVal a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.ptrVal c)
+  | .ann τ a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.ann τ c)
+  | .u8BitDecomposition a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.u8BitDecomposition c)
+  | .u8ShiftLeft a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.u8ShiftLeft c)
+  | .u8ShiftRight a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.u8ShiftRight c)
+  | .toField a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.toField c)
+  | .u8FromFieldUnsafe a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.u8FromFieldUnsafe c)
+  | .u8Xor a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                  match cs with | [a, b] => Term.wrapLets fs (.u8Xor a b) | _ => t
+  | .u8Add a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                  match cs with | [a, b] => Term.wrapLets fs (.u8Add a b) | _ => t
+  | .u8Mul a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                  match cs with | [a, b] => Term.wrapLets fs (.u8Mul a b) | _ => t
+  | .u8Sub a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                  match cs with | [a, b] => Term.wrapLets fs (.u8Sub a b) | _ => t
+  | .u8And a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                  match cs with | [a, b] => Term.wrapLets fs (.u8And a b) | _ => t
+  | .u8Or a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                 match cs with | [a, b] => Term.wrapLets fs (.u8Or a b) | _ => t
+  | .u8LessThan a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                       match cs with | [a, b] => Term.wrapLets fs (.u8LessThan a b) | _ => t
+  | .u32LessThan a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                        match cs with | [a, b] => Term.wrapLets fs (.u32LessThan a b) | _ => t
+  | .u8ChainRotr7 a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                         match cs with | [a, b] => Term.wrapLets fs (.u8ChainRotr7 a b) | _ => t
+  | .u8ChainRotr4 a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                         match cs with | [a, b] => Term.wrapLets fs (.u8ChainRotr4 a b) | _ => t
+  | .unconstrainedBigUintDivMod a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                                       match cs with | [a, b] => Term.wrapLets fs (.unconstrainedBigUintDivMod a b) | _ => t
+  | .u8RangeCheck a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                         match cs with | [a, b] => Term.wrapLets fs (.u8RangeCheck a b) | _ => t
+termination_by t => sizeOf t
+decreasing_by
+  all_goals first
+    | decreasing_tactic
+    | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+    | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+
+/-- Kahn-style topological sort of the inline-dependency graph: each pass
+emits every function whose inline-callees are already emitted, so callees
+precede callers. `rounds` bounds the number of passes by the function count
+— a DAG on N nodes has depth < N, so N passes suffice — which is the honest
+structural termination measure (not an arbitrary fuel cap). A non-empty
+remaining set with no ready function is an inline cycle and is rejected. -/
+def inlineTopo (deps : Std.HashMap Global (List Global)) :
+    Nat → List Global → Std.HashSet Global → List Global → Except String (List Global)
+  | 0, remaining, _, acc =>
+    if remaining.isEmpty then pure acc
+    else throw "inline recursion: dependency graph did not converge"
+  | rounds + 1, remaining, emitted, acc =>
+    match remaining with
+    | [] => pure acc
+    | _ =>
+      let (ready, notReady) := remaining.partition fun g =>
+        (deps.getD g []).all emitted.contains
+      match ready with
+      | [] =>
+        throw s!"inline recursion among: {remaining.map Global.toName}"
+      | _ =>
+        let emitted := ready.foldl (fun s g => s.insert g) emitted
+        inlineTopo deps rounds notReady emitted (acc ++ ready)
+termination_by rounds _ _ _ => rounds
+
+/-- Inline-expand every function body in the toplevel, eliminating all
+`.inlined` applications. Run before typechecking.
+
+Bottom-up and fuel-free: `.inlined` calls form a DAG (cycles are rejected as
+inline recursion), so functions are expanded in topological order — every
+callee is fully expanded before any caller inlines it. Each body is therefore
+expanded exactly once (`Term.expandOnce`, structurally recursive on the term),
+and its already-inline-free result is memoized in `done` and spliced (with
+α-renaming) at every call site. -/
+def Toplevel.inlineCalls (t : Toplevel) : Except String Toplevel := do
+  let funcs : Std.HashMap Global Function :=
+    t.functions.foldl (fun m f => m.insert f.name f) ∅
+  -- Inline dependencies per function, validating callee existence and arity.
+  let deps : Std.HashMap Global (List Global) ← t.functions.foldlM (init := ∅)
+    fun deps f => do
+      let gs ← f.body.inlineCallSites.foldlM (init := ([] : List Global))
+        fun acc (g, n) => do
+          let some callee := funcs[g]?
+            | throw s!"inline call to unknown function `{g.toName}`"
+          if n != callee.inputs.length then
+            throw s!"inline `{g.toName}`: got {n} args, expects {callee.inputs.length}"
+          pure (acc ++ [g])
+      pure (deps.insert f.name gs)
+  -- Topological order (callees first). `funcs.size` rounds bound the passes.
+  let names := t.functions.toList.map Function.name
+  let order ← inlineTopo deps names.length names ∅ []
+  -- Expand each body once, in order, memoizing the inline-free result.
+  let done : Std.HashMap Global (List Local × Term) := order.foldl (init := ∅)
+    fun done g =>
+      match funcs[g]? with
+      | none => done
+      | some f => done.insert g (f.inputs.map Prod.fst, (f.body.expandOnce done 0).2)
+  -- Rebuild each function with its expanded body, then hoist argument-position
+  -- lets that splicing may have introduced.
+  let functions := t.functions.map fun f =>
+    match done[f.name]? with
+    | none => f
+    | some (_, body) => { f with body := body.hoistLets }
+  pure { t with functions }
+
 inductive Declaration
   | function : Function → Declaration
   | dataType : DataType → Declaration

From d3215d991d4bd76650c517755950fbf9e3ce89d5 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sat, 11 Jul 2026 13:46:44 -0700
Subject: [PATCH 05/22] Aiur sha256: extract round/schedule word-ops into
 @-inlined helpers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The round and message schedule were walls of inlined byte arithmetic —
repeated big-endian carry chains, per-word rotation recompositions,
ch/maj blobs. With `@`-inlined calls costing nothing, factor them into
named helpers: u32_be_add, u32_xor, u32_and, u32_not, ch, maj, and the
four sigmas (big_sigma0/1, small_sigma0/1, each decomposing its word's
bytes once and recomposing the rotations). The round and schedule fold
bodies become legible dataflow calling them `@`-inlined; the whole
compression still compiles to one block circuit.

Probe (1 hash, 2048 bytes, non-periodic LCG): 5,906,938 FFT,
byte-identical to the hand-inlined version — extraction is free.
`aiur-hashes` sha256 cases green (execute/claim/prove-verify).
---
 Ix/IxVM/Sha256.lean | 443 +++++++++++++++++---------------------------
 1 file changed, 172 insertions(+), 271 deletions(-)

diff --git a/Ix/IxVM/Sha256.lean b/Ix/IxVM/Sha256.lean
index 5388ad17..82469d02 100644
--- a/Ix/IxVM/Sha256.lean
+++ b/Ix/IxVM/Sha256.lean
@@ -596,6 +596,161 @@ def sha256 := ⟦
     fill_W_and_run_rounds(W, state)
   }
 
+  /- # Word-op helpers (all `@`-inlined into the round / schedule folds). -/
+
+  -- Big-endian 32-bit add (index 3 = LSB); mutually-exclusive carries fold
+  -- with a free field `+`.
+  fn u32_be_add(a: [U8; 4], b: [U8; 4]) -> [U8; 4] {
+    let (s0, c1) = u8_add(a[3], b[3]);
+    let (t1, o1) = u8_add(a[2], b[2]);
+    let (s1, c1a) = u8_add(t1, c1);
+    let c2 = u8_from_field_unsafe(to_field(o1) + to_field(c1a));
+    let (t2, o2) = u8_add(a[1], b[1]);
+    let (s2, c2a) = u8_add(t2, c2);
+    let c3 = u8_from_field_unsafe(to_field(o2) + to_field(c2a));
+    let (t3, _x) = u8_add(a[0], b[0]);
+    let (s3, _x) = u8_add(t3, c3);
+    [s3, s2, s1, s0]
+  }
+
+  fn u32_xor(a: [U8; 4], b: [U8; 4]) -> [U8; 4] {
+    [u8_xor(a[0], b[0]), u8_xor(a[1], b[1]), u8_xor(a[2], b[2]), u8_xor(a[3], b[3])]
+  }
+
+  fn u32_and(a: [U8; 4], b: [U8; 4]) -> [U8; 4] {
+    [u8_and(a[0], b[0]), u8_and(a[1], b[1]), u8_and(a[2], b[2]), u8_and(a[3], b[3])]
+  }
+
+  fn u32_not(a: [U8; 4]) -> [U8; 4] {
+    [u8_from_field_unsafe(255 - to_field(a[0])), u8_from_field_unsafe(255 - to_field(a[1])),
+     u8_from_field_unsafe(255 - to_field(a[2])), u8_from_field_unsafe(255 - to_field(a[3]))]
+  }
+
+  -- ch = (e & f) ^ (~e & g).
+  fn ch(e: [U8; 4], f: [U8; 4], g: [U8; 4]) -> [U8; 4] {
+    @u32_xor(@u32_and(e, f), @u32_and(@u32_not(e), g))
+  }
+
+  -- maj = (a & b) ^ (a & c) ^ (b & c).
+  fn maj(a: [U8; 4], b: [U8; 4], c: [U8; 4]) -> [U8; 4] {
+    @u32_xor(@u32_and(a, b), @u32_xor(@u32_and(a, c), @u32_and(b, c)))
+  }
+
+  -- The four SHA-256 sigmas. Each decomposes its word's bytes ONCE (b0 =
+  -- LSB byte w[3] .. b3 = MSB byte w[0]) and recomposes the rotations as
+  -- weighted bit sums (pure arithmetic: no aux/lookup), then xors them.
+
+  -- Sigma1(e) = rotr6 ^ rotr11 ^ rotr25.
+  fn big_sigma1(w: [U8; 4]) -> [U8; 4] {
+    let b0 = u8_bit_decomposition(w[3]);
+    let b1 = u8_bit_decomposition(w[2]);
+    let b2 = u8_bit_decomposition(w[1]);
+    let b3 = u8_bit_decomposition(w[0]);
+    let r6 = [
+      u8_from_field_unsafe(b3[6] + 2 * b3[7] + 4 * b0[0] + 8 * b0[1] + 16 * b0[2] + 32 * b0[3] + 64 * b0[4] + 128 * b0[5]),
+      u8_from_field_unsafe(b2[6] + 2 * b2[7] + 4 * b3[0] + 8 * b3[1] + 16 * b3[2] + 32 * b3[3] + 64 * b3[4] + 128 * b3[5]),
+      u8_from_field_unsafe(b1[6] + 2 * b1[7] + 4 * b2[0] + 8 * b2[1] + 16 * b2[2] + 32 * b2[3] + 64 * b2[4] + 128 * b2[5]),
+      u8_from_field_unsafe(b0[6] + 2 * b0[7] + 4 * b1[0] + 8 * b1[1] + 16 * b1[2] + 32 * b1[3] + 64 * b1[4] + 128 * b1[5])
+    ];
+    let r11 = [
+      u8_from_field_unsafe(b0[3] + 2 * b0[4] + 4 * b0[5] + 8 * b0[6] + 16 * b0[7] + 32 * b1[0] + 64 * b1[1] + 128 * b1[2]),
+      u8_from_field_unsafe(b3[3] + 2 * b3[4] + 4 * b3[5] + 8 * b3[6] + 16 * b3[7] + 32 * b0[0] + 64 * b0[1] + 128 * b0[2]),
+      u8_from_field_unsafe(b2[3] + 2 * b2[4] + 4 * b2[5] + 8 * b2[6] + 16 * b2[7] + 32 * b3[0] + 64 * b3[1] + 128 * b3[2]),
+      u8_from_field_unsafe(b1[3] + 2 * b1[4] + 4 * b1[5] + 8 * b1[6] + 16 * b1[7] + 32 * b2[0] + 64 * b2[1] + 128 * b2[2])
+    ];
+    let r25 = [
+      u8_from_field_unsafe(b2[1] + 2 * b2[2] + 4 * b2[3] + 8 * b2[4] + 16 * b2[5] + 32 * b2[6] + 64 * b2[7] + 128 * b3[0]),
+      u8_from_field_unsafe(b1[1] + 2 * b1[2] + 4 * b1[3] + 8 * b1[4] + 16 * b1[5] + 32 * b1[6] + 64 * b1[7] + 128 * b2[0]),
+      u8_from_field_unsafe(b0[1] + 2 * b0[2] + 4 * b0[3] + 8 * b0[4] + 16 * b0[5] + 32 * b0[6] + 64 * b0[7] + 128 * b1[0]),
+      u8_from_field_unsafe(b3[1] + 2 * b3[2] + 4 * b3[3] + 8 * b3[4] + 16 * b3[5] + 32 * b3[6] + 64 * b3[7] + 128 * b0[0])
+    ];
+    @u32_xor(r6, @u32_xor(r11, r25))
+  }
+
+  -- Sigma0(a) = rotr2 ^ rotr13 ^ rotr22.
+  fn big_sigma0(w: [U8; 4]) -> [U8; 4] {
+    let b0 = u8_bit_decomposition(w[3]);
+    let b1 = u8_bit_decomposition(w[2]);
+    let b2 = u8_bit_decomposition(w[1]);
+    let b3 = u8_bit_decomposition(w[0]);
+    let r2 = [
+      u8_from_field_unsafe(b3[2] + 2 * b3[3] + 4 * b3[4] + 8 * b3[5] + 16 * b3[6] + 32 * b3[7] + 64 * b0[0] + 128 * b0[1]),
+      u8_from_field_unsafe(b2[2] + 2 * b2[3] + 4 * b2[4] + 8 * b2[5] + 16 * b2[6] + 32 * b2[7] + 64 * b3[0] + 128 * b3[1]),
+      u8_from_field_unsafe(b1[2] + 2 * b1[3] + 4 * b1[4] + 8 * b1[5] + 16 * b1[6] + 32 * b1[7] + 64 * b2[0] + 128 * b2[1]),
+      u8_from_field_unsafe(b0[2] + 2 * b0[3] + 4 * b0[4] + 8 * b0[5] + 16 * b0[6] + 32 * b0[7] + 64 * b1[0] + 128 * b1[1])
+    ];
+    let r13 = [
+      u8_from_field_unsafe(b0[5] + 2 * b0[6] + 4 * b0[7] + 8 * b1[0] + 16 * b1[1] + 32 * b1[2] + 64 * b1[3] + 128 * b1[4]),
+      u8_from_field_unsafe(b3[5] + 2 * b3[6] + 4 * b3[7] + 8 * b0[0] + 16 * b0[1] + 32 * b0[2] + 64 * b0[3] + 128 * b0[4]),
+      u8_from_field_unsafe(b2[5] + 2 * b2[6] + 4 * b2[7] + 8 * b3[0] + 16 * b3[1] + 32 * b3[2] + 64 * b3[3] + 128 * b3[4]),
+      u8_from_field_unsafe(b1[5] + 2 * b1[6] + 4 * b1[7] + 8 * b2[0] + 16 * b2[1] + 32 * b2[2] + 64 * b2[3] + 128 * b2[4])
+    ];
+    let r22 = [
+      u8_from_field_unsafe(b1[6] + 2 * b1[7] + 4 * b2[0] + 8 * b2[1] + 16 * b2[2] + 32 * b2[3] + 64 * b2[4] + 128 * b2[5]),
+      u8_from_field_unsafe(b0[6] + 2 * b0[7] + 4 * b1[0] + 8 * b1[1] + 16 * b1[2] + 32 * b1[3] + 64 * b1[4] + 128 * b1[5]),
+      u8_from_field_unsafe(b3[6] + 2 * b3[7] + 4 * b0[0] + 8 * b0[1] + 16 * b0[2] + 32 * b0[3] + 64 * b0[4] + 128 * b0[5]),
+      u8_from_field_unsafe(b2[6] + 2 * b2[7] + 4 * b3[0] + 8 * b3[1] + 16 * b3[2] + 32 * b3[3] + 64 * b3[4] + 128 * b3[5])
+    ];
+    @u32_xor(r2, @u32_xor(r13, r22))
+  }
+
+  -- sigma0(w) = rotr7 ^ rotr18 ^ shr3.
+  fn small_sigma0(w: [U8; 4]) -> [U8; 4] {
+    let b0 = u8_bit_decomposition(w[3]);
+    let b1 = u8_bit_decomposition(w[2]);
+    let b2 = u8_bit_decomposition(w[1]);
+    let b3 = u8_bit_decomposition(w[0]);
+    let r7 = [
+      u8_from_field_unsafe(b3[7] + 2 * b0[0] + 4 * b0[1] + 8 * b0[2] + 16 * b0[3] + 32 * b0[4] + 64 * b0[5] + 128 * b0[6]),
+      u8_from_field_unsafe(b2[7] + 2 * b3[0] + 4 * b3[1] + 8 * b3[2] + 16 * b3[3] + 32 * b3[4] + 64 * b3[5] + 128 * b3[6]),
+      u8_from_field_unsafe(b1[7] + 2 * b2[0] + 4 * b2[1] + 8 * b2[2] + 16 * b2[3] + 32 * b2[4] + 64 * b2[5] + 128 * b2[6]),
+      u8_from_field_unsafe(b0[7] + 2 * b1[0] + 4 * b1[1] + 8 * b1[2] + 16 * b1[3] + 32 * b1[4] + 64 * b1[5] + 128 * b1[6])
+    ];
+    let r18 = [
+      u8_from_field_unsafe(b1[2] + 2 * b1[3] + 4 * b1[4] + 8 * b1[5] + 16 * b1[6] + 32 * b1[7] + 64 * b2[0] + 128 * b2[1]),
+      u8_from_field_unsafe(b0[2] + 2 * b0[3] + 4 * b0[4] + 8 * b0[5] + 16 * b0[6] + 32 * b0[7] + 64 * b1[0] + 128 * b1[1]),
+      u8_from_field_unsafe(b3[2] + 2 * b3[3] + 4 * b3[4] + 8 * b3[5] + 16 * b3[6] + 32 * b3[7] + 64 * b0[0] + 128 * b0[1]),
+      u8_from_field_unsafe(b2[2] + 2 * b2[3] + 4 * b2[4] + 8 * b2[5] + 16 * b2[6] + 32 * b2[7] + 64 * b3[0] + 128 * b3[1])
+    ];
+    let s3 = [
+      u8_from_field_unsafe(b3[3] + 2 * b3[4] + 4 * b3[5] + 8 * b3[6] + 16 * b3[7]),
+      u8_from_field_unsafe(b2[3] + 2 * b2[4] + 4 * b2[5] + 8 * b2[6] + 16 * b2[7] + 32 * b3[0] + 64 * b3[1] + 128 * b3[2]),
+      u8_from_field_unsafe(b1[3] + 2 * b1[4] + 4 * b1[5] + 8 * b1[6] + 16 * b1[7] + 32 * b2[0] + 64 * b2[1] + 128 * b2[2]),
+      u8_from_field_unsafe(b0[3] + 2 * b0[4] + 4 * b0[5] + 8 * b0[6] + 16 * b0[7] + 32 * b1[0] + 64 * b1[1] + 128 * b1[2])
+    ];
+    @u32_xor(r7, @u32_xor(r18, s3))
+  }
+
+  -- sigma1(w) = rotr17 ^ rotr19 ^ shr10. shr10's top byte is the constant
+  -- 0, so byte 0 of the result xors only two operands.
+  fn small_sigma1(w: [U8; 4]) -> [U8; 4] {
+    let b0 = u8_bit_decomposition(w[3]);
+    let b1 = u8_bit_decomposition(w[2]);
+    let b2 = u8_bit_decomposition(w[1]);
+    let b3 = u8_bit_decomposition(w[0]);
+    let r17 = [
+      u8_from_field_unsafe(b1[1] + 2 * b1[2] + 4 * b1[3] + 8 * b1[4] + 16 * b1[5] + 32 * b1[6] + 64 * b1[7] + 128 * b2[0]),
+      u8_from_field_unsafe(b0[1] + 2 * b0[2] + 4 * b0[3] + 8 * b0[4] + 16 * b0[5] + 32 * b0[6] + 64 * b0[7] + 128 * b1[0]),
+      u8_from_field_unsafe(b3[1] + 2 * b3[2] + 4 * b3[3] + 8 * b3[4] + 16 * b3[5] + 32 * b3[6] + 64 * b3[7] + 128 * b0[0]),
+      u8_from_field_unsafe(b2[1] + 2 * b2[2] + 4 * b2[3] + 8 * b2[4] + 16 * b2[5] + 32 * b2[6] + 64 * b2[7] + 128 * b3[0])
+    ];
+    let r19 = [
+      u8_from_field_unsafe(b1[3] + 2 * b1[4] + 4 * b1[5] + 8 * b1[6] + 16 * b1[7] + 32 * b2[0] + 64 * b2[1] + 128 * b2[2]),
+      u8_from_field_unsafe(b0[3] + 2 * b0[4] + 4 * b0[5] + 8 * b0[6] + 16 * b0[7] + 32 * b1[0] + 64 * b1[1] + 128 * b1[2]),
+      u8_from_field_unsafe(b3[3] + 2 * b3[4] + 4 * b3[5] + 8 * b3[6] + 16 * b3[7] + 32 * b0[0] + 64 * b0[1] + 128 * b0[2]),
+      u8_from_field_unsafe(b2[3] + 2 * b2[4] + 4 * b2[5] + 8 * b2[6] + 16 * b2[7] + 32 * b3[0] + 64 * b3[1] + 128 * b3[2])
+    ];
+    let s10 = [
+      u8_from_field_unsafe(b3[2] + 2 * b3[3] + 4 * b3[4] + 8 * b3[5] + 16 * b3[6] + 32 * b3[7]),
+      u8_from_field_unsafe(b2[2] + 2 * b2[3] + 4 * b2[4] + 8 * b2[5] + 16 * b2[6] + 32 * b2[7] + 64 * b3[0] + 128 * b3[1]),
+      u8_from_field_unsafe(b1[2] + 2 * b1[3] + 4 * b1[4] + 8 * b1[5] + 16 * b1[6] + 32 * b1[7] + 64 * b2[0] + 128 * b2[1])
+    ];
+    [u8_xor(r17[0], r19[0]),
+     u8_xor(r17[1], u8_xor(r19[1], s10[0])),
+     u8_xor(r17[2], u8_xor(r19[2], s10[1])),
+     u8_xor(r17[3], u8_xor(r19[3], s10[2]))]
+  }
+
   fn fill_W_and_run_rounds(W: [[U8; 4]; 16], state: [[U8; 4]; 8]) -> [[U8; 4]; 8] {
     let K = [
       [0x42u8, 0x8au8, 0x2fu8, 0x98u8], [0x71u8, 0x37u8, 0x44u8, 0x91u8], [0xb5u8, 0xc0u8, 0xfbu8, 0xcfu8], [0xe9u8, 0xb5u8, 0xdbu8, 0xa5u8],
@@ -623,289 +778,35 @@ def sha256 := ⟦
     let Wx = [[0u8; 4]; 64];
     let Wx = fold(0 .. 16, Wx, |Wx, @j| set(Wx, @j, W[@j]));
     let Wx = fold(16 .. 64, Wx, |Wx, @i|
-      let [w15_b3, w15_b2, w15_b1, w15_b0] = Wx[@i - 15];
-      let [w15_b0_0, w15_b0_1, w15_b0_2, w15_b0_3, w15_b0_4, w15_b0_5, w15_b0_6, w15_b0_7] = u8_bit_decomposition(w15_b0);
-      let [w15_b1_0, w15_b1_1, w15_b1_2, w15_b1_3, w15_b1_4, w15_b1_5, w15_b1_6, w15_b1_7] = u8_bit_decomposition(w15_b1);
-      let [w15_b2_0, w15_b2_1, w15_b2_2, w15_b2_3, w15_b2_4, w15_b2_5, w15_b2_6, w15_b2_7] = u8_bit_decomposition(w15_b2);
-      let [w15_b3_0, w15_b3_1, w15_b3_2, w15_b3_3, w15_b3_4, w15_b3_5, w15_b3_6, w15_b3_7] = u8_bit_decomposition(w15_b3);
-
-      let w15_rotr7 = [
-        u8_from_field_unsafe(w15_b3_7 + 2 * w15_b0_0 + 4 * w15_b0_1 + 8 * w15_b0_2 + 16 * w15_b0_3 + 32 * w15_b0_4 + 64 * w15_b0_5 + 128 * w15_b0_6),
-        u8_from_field_unsafe(w15_b2_7 + 2 * w15_b3_0 + 4 * w15_b3_1 + 8 * w15_b3_2 + 16 * w15_b3_3 + 32 * w15_b3_4 + 64 * w15_b3_5 + 128 * w15_b3_6),
-        u8_from_field_unsafe(w15_b1_7 + 2 * w15_b2_0 + 4 * w15_b2_1 + 8 * w15_b2_2 + 16 * w15_b2_3 + 32 * w15_b2_4 + 64 * w15_b2_5 + 128 * w15_b2_6),
-        u8_from_field_unsafe(w15_b0_7 + 2 * w15_b1_0 + 4 * w15_b1_1 + 8 * w15_b1_2 + 16 * w15_b1_3 + 32 * w15_b1_4 + 64 * w15_b1_5 + 128 * w15_b1_6)
-      ];
-
-      let w15_rotr18 = [
-        u8_from_field_unsafe(w15_b1_2 + 2 * w15_b1_3 + 4 * w15_b1_4 + 8 * w15_b1_5 + 16 * w15_b1_6 + 32 * w15_b1_7 + 64 * w15_b2_0 + 128 * w15_b2_1),
-        u8_from_field_unsafe(w15_b0_2 + 2 * w15_b0_3 + 4 * w15_b0_4 + 8 * w15_b0_5 + 16 * w15_b0_6 + 32 * w15_b0_7 + 64 * w15_b1_0 + 128 * w15_b1_1),
-        u8_from_field_unsafe(w15_b3_2 + 2 * w15_b3_3 + 4 * w15_b3_4 + 8 * w15_b3_5 + 16 * w15_b3_6 + 32 * w15_b3_7 + 64 * w15_b0_0 + 128 * w15_b0_1),
-        u8_from_field_unsafe(w15_b2_2 + 2 * w15_b2_3 + 4 * w15_b2_4 + 8 * w15_b2_5 + 16 * w15_b2_6 + 32 * w15_b2_7 + 64 * w15_b3_0 + 128 * w15_b3_1)
-      ];
-
-      let w15_shr3 = [
-        u8_from_field_unsafe(w15_b3_3 + 2 * w15_b3_4 + 4 * w15_b3_5 + 8 * w15_b3_6 + 16 * w15_b3_7),
-        u8_from_field_unsafe(w15_b2_3 + 2 * w15_b2_4 + 4 * w15_b2_5 + 8 * w15_b2_6 + 16 * w15_b2_7 + 32 * w15_b3_0 + 64 * w15_b3_1 + 128 * w15_b3_2),
-        u8_from_field_unsafe(w15_b1_3 + 2 * w15_b1_4 + 4 * w15_b1_5 + 8 * w15_b1_6 + 16 * w15_b1_7 + 32 * w15_b2_0 + 64 * w15_b2_1 + 128 * w15_b2_2),
-        u8_from_field_unsafe(w15_b0_3 + 2 * w15_b0_4 + 4 * w15_b0_5 + 8 * w15_b0_6 + 16 * w15_b0_7 + 32 * w15_b1_0 + 64 * w15_b1_1 + 128 * w15_b1_2)
-      ];
-
-      let [w2_b3, w2_b2, w2_b1, w2_b0] = Wx[@i - 2];
-      let [w2_b0_0, w2_b0_1, w2_b0_2, w2_b0_3, w2_b0_4, w2_b0_5, w2_b0_6, w2_b0_7] = u8_bit_decomposition(w2_b0);
-      let [w2_b1_0, w2_b1_1, w2_b1_2, w2_b1_3, w2_b1_4, w2_b1_5, w2_b1_6, w2_b1_7] = u8_bit_decomposition(w2_b1);
-      let [w2_b2_0, w2_b2_1, w2_b2_2, w2_b2_3, w2_b2_4, w2_b2_5, w2_b2_6, w2_b2_7] = u8_bit_decomposition(w2_b2);
-      let [w2_b3_0, w2_b3_1, w2_b3_2, w2_b3_3, w2_b3_4, w2_b3_5, w2_b3_6, w2_b3_7] = u8_bit_decomposition(w2_b3);
-
-      let w2_rotr17 = [
-        u8_from_field_unsafe(w2_b1_1 + 2 * w2_b1_2 + 4 * w2_b1_3 + 8 * w2_b1_4 + 16 * w2_b1_5 + 32 * w2_b1_6 + 64 * w2_b1_7 + 128 * w2_b2_0),
-        u8_from_field_unsafe(w2_b0_1 + 2 * w2_b0_2 + 4 * w2_b0_3 + 8 * w2_b0_4 + 16 * w2_b0_5 + 32 * w2_b0_6 + 64 * w2_b0_7 + 128 * w2_b1_0),
-        u8_from_field_unsafe(w2_b3_1 + 2 * w2_b3_2 + 4 * w2_b3_3 + 8 * w2_b3_4 + 16 * w2_b3_5 + 32 * w2_b3_6 + 64 * w2_b3_7 + 128 * w2_b0_0),
-        u8_from_field_unsafe(w2_b2_1 + 2 * w2_b2_2 + 4 * w2_b2_3 + 8 * w2_b2_4 + 16 * w2_b2_5 + 32 * w2_b2_6 + 64 * w2_b2_7 + 128 * w2_b3_0)
-      ];
-
-      let w2_rotr19 = [
-        u8_from_field_unsafe(w2_b1_3 + 2 * w2_b1_4 + 4 * w2_b1_5 + 8 * w2_b1_6 + 16 * w2_b1_7 + 32 * w2_b2_0 + 64 * w2_b2_1 + 128 * w2_b2_2),
-        u8_from_field_unsafe(w2_b0_3 + 2 * w2_b0_4 + 4 * w2_b0_5 + 8 * w2_b0_6 + 16 * w2_b0_7 + 32 * w2_b1_0 + 64 * w2_b1_1 + 128 * w2_b1_2),
-        u8_from_field_unsafe(w2_b3_3 + 2 * w2_b3_4 + 4 * w2_b3_5 + 8 * w2_b3_6 + 16 * w2_b3_7 + 32 * w2_b0_0 + 64 * w2_b0_1 + 128 * w2_b0_2),
-        u8_from_field_unsafe(w2_b2_3 + 2 * w2_b2_4 + 4 * w2_b2_5 + 8 * w2_b2_6 + 16 * w2_b2_7 + 32 * w2_b3_0 + 64 * w2_b3_1 + 128 * w2_b3_2)
-      ];
-
-      -- shr10's top byte is the constant 0; only the three live bytes are
-      -- materialized, and s1's byte 0 xors two operands instead of three.
-      let w2_shr10 = [
-        u8_from_field_unsafe(w2_b3_2 + 2 * w2_b3_3 + 4 * w2_b3_4 + 8 * w2_b3_5 + 16 * w2_b3_6 + 32 * w2_b3_7),
-        u8_from_field_unsafe(w2_b2_2 + 2 * w2_b2_3 + 4 * w2_b2_4 + 8 * w2_b2_5 + 16 * w2_b2_6 + 32 * w2_b2_7 + 64 * w2_b3_0 + 128 * w2_b3_1),
-        u8_from_field_unsafe(w2_b1_2 + 2 * w2_b1_3 + 4 * w2_b1_4 + 8 * w2_b1_5 + 16 * w2_b1_6 + 32 * w2_b1_7 + 64 * w2_b2_0 + 128 * w2_b2_1)
-      ];
-
-      let ws0 = [
-        u8_xor(w15_rotr7[0], u8_xor(w15_rotr18[0], w15_shr3[0])),
-        u8_xor(w15_rotr7[1], u8_xor(w15_rotr18[1], w15_shr3[1])),
-        u8_xor(w15_rotr7[2], u8_xor(w15_rotr18[2], w15_shr3[2])),
-        u8_xor(w15_rotr7[3], u8_xor(w15_rotr18[3], w15_shr3[3]))
-      ];
-      let ws1 = [
-        u8_xor(w2_rotr17[0], w2_rotr19[0]),
-        u8_xor(w2_rotr17[1], u8_xor(w2_rotr19[1], w2_shr10[0])),
-        u8_xor(w2_rotr17[2], u8_xor(w2_rotr19[2], w2_shr10[1])),
-        u8_xor(w2_rotr17[3], u8_xor(w2_rotr19[3], w2_shr10[2]))
-      ];
-
-      -- W_i = W_i-16 ⊞ s0 ⊞ W_i-7 ⊞ s1 (big-endian u8_add carry chains).
-      let (ss0, ssc1) = u8_add(ws0[3], ws1[3]);
-      let (sst1, sso1) = u8_add(ws0[2], ws1[2]);
-      let (ss1, ssc1a) = u8_add(sst1, ssc1);
-      let ssc2 = u8_from_field_unsafe(to_field(sso1) + to_field(ssc1a));
-      let (sst2, sso2) = u8_add(ws0[1], ws1[1]);
-      let (ss2, ssc2a) = u8_add(sst2, ssc2);
-      let ssc3 = u8_from_field_unsafe(to_field(sso2) + to_field(ssc2a));
-      let (sst3, _x) = u8_add(ws0[0], ws1[0]);
-      let (ss3, _x) = u8_add(sst3, ssc3);
-
+      -- W_i = W_i-16 + sigma0(W_i-15) + W_i-7 + sigma1(W_i-2).
+      let w15 = Wx[@i - 15];
+      let w2 = Wx[@i - 2];
       let w16 = Wx[@i - 16];
       let w7 = Wx[@i - 7];
-      let (ww0, wwc1) = u8_add(w16[3], w7[3]);
-      let (wwt1, wwo1) = u8_add(w16[2], w7[2]);
-      let (ww1, wwc1a) = u8_add(wwt1, wwc1);
-      let wwc2 = u8_from_field_unsafe(to_field(wwo1) + to_field(wwc1a));
-      let (wwt2, wwo2) = u8_add(w16[1], w7[1]);
-      let (ww2, wwc2a) = u8_add(wwt2, wwc2);
-      let wwc3 = u8_from_field_unsafe(to_field(wwo2) + to_field(wwc2a));
-      let (wwt3, _x) = u8_add(w16[0], w7[0]);
-      let (ww3, _x) = u8_add(wwt3, wwc3);
-
-      let (wi0, wic1) = u8_add(ss0, ww0);
-      let (wit1, wio1) = u8_add(ss1, ww1);
-      let (wi1, wic1a) = u8_add(wit1, wic1);
-      let wic2 = u8_from_field_unsafe(to_field(wio1) + to_field(wic1a));
-      let (wit2, wio2) = u8_add(ss2, ww2);
-      let (wi2, wic2a) = u8_add(wit2, wic2);
-      let wic3 = u8_from_field_unsafe(to_field(wio2) + to_field(wic2a));
-      let (wit3, _x) = u8_add(ss3, ww3);
-      let (wi3, _x) = u8_add(wit3, wic3);
-      set(Wx, @i, [wi3, wi2, wi1, wi0])
+      let s0 = @small_sigma0(w15);
+      let s1 = @small_sigma1(w2);
+      set(Wx, @i, @u32_be_add(w16, @u32_be_add(s0, @u32_be_add(w7, s1))))
     );
     let W = Wx;
 
     let state_new = fold(0 .. 64, state, |acc, @i|
-      let e_0_bits = u8_bit_decomposition(acc[4][3]);
-      let e_1_bits = u8_bit_decomposition(acc[4][2]);
-      let e_2_bits = u8_bit_decomposition(acc[4][1]);
-      let e_3_bits = u8_bit_decomposition(acc[4][0]);
-
-      -- Each rotated/shifted byte is the weighted sum of 8 bits. Written
-      -- inline: it is pure arithmetic, so it costs no aux column or lookup.
-      let e_rotr6 = [
-        u8_from_field_unsafe(e_3_bits[6] + 2 * e_3_bits[7] + 4 * e_0_bits[0] + 8 * e_0_bits[1] + 16 * e_0_bits[2] + 32 * e_0_bits[3] + 64 * e_0_bits[4] + 128 * e_0_bits[5]),
-        u8_from_field_unsafe(e_2_bits[6] + 2 * e_2_bits[7] + 4 * e_3_bits[0] + 8 * e_3_bits[1] + 16 * e_3_bits[2] + 32 * e_3_bits[3] + 64 * e_3_bits[4] + 128 * e_3_bits[5]),
-        u8_from_field_unsafe(e_1_bits[6] + 2 * e_1_bits[7] + 4 * e_2_bits[0] + 8 * e_2_bits[1] + 16 * e_2_bits[2] + 32 * e_2_bits[3] + 64 * e_2_bits[4] + 128 * e_2_bits[5]),
-        u8_from_field_unsafe(e_0_bits[6] + 2 * e_0_bits[7] + 4 * e_1_bits[0] + 8 * e_1_bits[1] + 16 * e_1_bits[2] + 32 * e_1_bits[3] + 64 * e_1_bits[4] + 128 * e_1_bits[5])
-      ];
-
-      let e_rotr11 = [
-        u8_from_field_unsafe(e_0_bits[3] + 2 * e_0_bits[4] + 4 * e_0_bits[5] + 8 * e_0_bits[6] + 16 * e_0_bits[7] + 32 * e_1_bits[0] + 64 * e_1_bits[1] + 128 * e_1_bits[2]),
-        u8_from_field_unsafe(e_3_bits[3] + 2 * e_3_bits[4] + 4 * e_3_bits[5] + 8 * e_3_bits[6] + 16 * e_3_bits[7] + 32 * e_0_bits[0] + 64 * e_0_bits[1] + 128 * e_0_bits[2]),
-        u8_from_field_unsafe(e_2_bits[3] + 2 * e_2_bits[4] + 4 * e_2_bits[5] + 8 * e_2_bits[6] + 16 * e_2_bits[7] + 32 * e_3_bits[0] + 64 * e_3_bits[1] + 128 * e_3_bits[2]),
-        u8_from_field_unsafe(e_1_bits[3] + 2 * e_1_bits[4] + 4 * e_1_bits[5] + 8 * e_1_bits[6] + 16 * e_1_bits[7] + 32 * e_2_bits[0] + 64 * e_2_bits[1] + 128 * e_2_bits[2])
-      ];
-
-      let e_rotr25 = [
-        u8_from_field_unsafe(e_2_bits[1] + 2 * e_2_bits[2] + 4 * e_2_bits[3] + 8 * e_2_bits[4] + 16 * e_2_bits[5] + 32 * e_2_bits[6] + 64 * e_2_bits[7] + 128 * e_3_bits[0]),
-        u8_from_field_unsafe(e_1_bits[1] + 2 * e_1_bits[2] + 4 * e_1_bits[3] + 8 * e_1_bits[4] + 16 * e_1_bits[5] + 32 * e_1_bits[6] + 64 * e_1_bits[7] + 128 * e_2_bits[0]),
-        u8_from_field_unsafe(e_0_bits[1] + 2 * e_0_bits[2] + 4 * e_0_bits[3] + 8 * e_0_bits[4] + 16 * e_0_bits[5] + 32 * e_0_bits[6] + 64 * e_0_bits[7] + 128 * e_1_bits[0]),
-        u8_from_field_unsafe(e_3_bits[1] + 2 * e_3_bits[2] + 4 * e_3_bits[3] + 8 * e_3_bits[4] + 16 * e_3_bits[5] + 32 * e_3_bits[6] + 64 * e_3_bits[7] + 128 * e_0_bits[0])
-      ];
-
-      let e_not = [u8_from_field_unsafe(255 - to_field(acc[4][0])), u8_from_field_unsafe(255 - to_field(acc[4][1])), u8_from_field_unsafe(255 - to_field(acc[4][2])), u8_from_field_unsafe(255 - to_field(acc[4][3]))];
-
-      -- Word ops inlined as byte ops (1 aux + 1 lookup each): a call to a
-      -- u32_* helper costs 4 output aux + 1 lookup here PLUS a row in the
-      -- helper's 26-35-wide circuit — the byte ops are less than half that.
-      let s1 = [
-        u8_xor(e_rotr6[0], u8_xor(e_rotr11[0], e_rotr25[0])),
-        u8_xor(e_rotr6[1], u8_xor(e_rotr11[1], e_rotr25[1])),
-        u8_xor(e_rotr6[2], u8_xor(e_rotr11[2], e_rotr25[2])),
-        u8_xor(e_rotr6[3], u8_xor(e_rotr11[3], e_rotr25[3]))
-      ];
-      let ch = [
-        u8_xor(u8_and(acc[4][0], acc[5][0]), u8_and(e_not[0], acc[6][0])),
-        u8_xor(u8_and(acc[4][1], acc[5][1]), u8_and(e_not[1], acc[6][1])),
-        u8_xor(u8_and(acc[4][2], acc[5][2]), u8_and(e_not[2], acc[6][2])),
-        u8_xor(u8_and(acc[4][3], acc[5][3]), u8_and(e_not[3], acc[6][3]))
-      ];
-      -- temp1 = h ⊞ s1 ⊞ ch ⊞ K[i] ⊞ W[i], big-endian byte-carry chains
-      -- (index 3 = LSB; carry folding mirrors `u32_be_add`).
-      let kw = K[@i];
+      -- acc = [a,b,c,d,e,f,g,h]; K[i], W[i] are the round constant and word.
+      let ki = K[@i];
       let wi = W[@i];
-      let (kw0, kwc1) = u8_add(kw[3], wi[3]);
-      let (kwt1, kwo1) = u8_add(kw[2], wi[2]);
-      let (kw1, kwc1a) = u8_add(kwt1, kwc1);
-      let kwc2 = u8_from_field_unsafe(to_field(kwo1) + to_field(kwc1a));
-      let (kwt2, kwo2) = u8_add(kw[1], wi[1]);
-      let (kw2, kwc2a) = u8_add(kwt2, kwc2);
-      let kwc3 = u8_from_field_unsafe(to_field(kwo2) + to_field(kwc2a));
-      let (kwt3, _x) = u8_add(kw[0], wi[0]);
-      let (kw3, _x) = u8_add(kwt3, kwc3);
-
-      let (sc0, scc1) = u8_add(s1[3], ch[3]);
-      let (sct1, sco1) = u8_add(s1[2], ch[2]);
-      let (sc1, scc1a) = u8_add(sct1, scc1);
-      let scc2 = u8_from_field_unsafe(to_field(sco1) + to_field(scc1a));
-      let (sct2, sco2) = u8_add(s1[1], ch[1]);
-      let (sc2, scc2a) = u8_add(sct2, scc2);
-      let scc3 = u8_from_field_unsafe(to_field(sco2) + to_field(scc2a));
-      let (sct3, _x) = u8_add(s1[0], ch[0]);
-      let (sc3, _x) = u8_add(sct3, scc3);
-
-      let (hs0, hsc1) = u8_add(acc[7][3], sc0);
-      let (hst1, hso1) = u8_add(acc[7][2], sc1);
-      let (hs1, hsc1a) = u8_add(hst1, hsc1);
-      let hsc2 = u8_from_field_unsafe(to_field(hso1) + to_field(hsc1a));
-      let (hst2, hso2) = u8_add(acc[7][1], sc2);
-      let (hs2, hsc2a) = u8_add(hst2, hsc2);
-      let hsc3 = u8_from_field_unsafe(to_field(hso2) + to_field(hsc2a));
-      let (hst3, _x) = u8_add(acc[7][0], sc3);
-      let (hs3, _x) = u8_add(hst3, hsc3);
-
-      let (t10, t1c1) = u8_add(hs0, kw0);
-      let (t1t1, t1o1) = u8_add(hs1, kw1);
-      let (t11, t1c1a) = u8_add(t1t1, t1c1);
-      let t1c2 = u8_from_field_unsafe(to_field(t1o1) + to_field(t1c1a));
-      let (t1t2, t1o2) = u8_add(hs2, kw2);
-      let (t12, t1c2a) = u8_add(t1t2, t1c2);
-      let t1c3 = u8_from_field_unsafe(to_field(t1o2) + to_field(t1c2a));
-      let (t1t3, _x) = u8_add(hs3, kw3);
-      let (t13, _x) = u8_add(t1t3, t1c3);
-
-      let a_0_bits = u8_bit_decomposition(acc[0][3]);
-      let a_1_bits = u8_bit_decomposition(acc[0][2]);
-      let a_2_bits = u8_bit_decomposition(acc[0][1]);
-      let a_3_bits = u8_bit_decomposition(acc[0][0]);
-
-      let a_rotr2 = [
-        u8_from_field_unsafe(a_3_bits[2] + 2 * a_3_bits[3] + 4 * a_3_bits[4] + 8 * a_3_bits[5] + 16 * a_3_bits[6] + 32 * a_3_bits[7] + 64 * a_0_bits[0] + 128 * a_0_bits[1]),
-        u8_from_field_unsafe(a_2_bits[2] + 2 * a_2_bits[3] + 4 * a_2_bits[4] + 8 * a_2_bits[5] + 16 * a_2_bits[6] + 32 * a_2_bits[7] + 64 * a_3_bits[0] + 128 * a_3_bits[1]),
-        u8_from_field_unsafe(a_1_bits[2] + 2 * a_1_bits[3] + 4 * a_1_bits[4] + 8 * a_1_bits[5] + 16 * a_1_bits[6] + 32 * a_1_bits[7] + 64 * a_2_bits[0] + 128 * a_2_bits[1]),
-        u8_from_field_unsafe(a_0_bits[2] + 2 * a_0_bits[3] + 4 * a_0_bits[4] + 8 * a_0_bits[5] + 16 * a_0_bits[6] + 32 * a_0_bits[7] + 64 * a_1_bits[0] + 128 * a_1_bits[1])
-      ];
-
-      let a_rotr13 = [
-        u8_from_field_unsafe(a_0_bits[5] + 2 * a_0_bits[6] + 4 * a_0_bits[7] + 8 * a_1_bits[0] + 16 * a_1_bits[1] + 32 * a_1_bits[2] + 64 * a_1_bits[3] + 128 * a_1_bits[4]),
-        u8_from_field_unsafe(a_3_bits[5] + 2 * a_3_bits[6] + 4 * a_3_bits[7] + 8 * a_0_bits[0] + 16 * a_0_bits[1] + 32 * a_0_bits[2] + 64 * a_0_bits[3] + 128 * a_0_bits[4]),
-        u8_from_field_unsafe(a_2_bits[5] + 2 * a_2_bits[6] + 4 * a_2_bits[7] + 8 * a_3_bits[0] + 16 * a_3_bits[1] + 32 * a_3_bits[2] + 64 * a_3_bits[3] + 128 * a_3_bits[4]),
-        u8_from_field_unsafe(a_1_bits[5] + 2 * a_1_bits[6] + 4 * a_1_bits[7] + 8 * a_2_bits[0] + 16 * a_2_bits[1] + 32 * a_2_bits[2] + 64 * a_2_bits[3] + 128 * a_2_bits[4])
-      ];
-
-      let a_rotr22 = [
-        u8_from_field_unsafe(a_1_bits[6] + 2 * a_1_bits[7] + 4 * a_2_bits[0] + 8 * a_2_bits[1] + 16 * a_2_bits[2] + 32 * a_2_bits[3] + 64 * a_2_bits[4] + 128 * a_2_bits[5]),
-        u8_from_field_unsafe(a_0_bits[6] + 2 * a_0_bits[7] + 4 * a_1_bits[0] + 8 * a_1_bits[1] + 16 * a_1_bits[2] + 32 * a_1_bits[3] + 64 * a_1_bits[4] + 128 * a_1_bits[5]),
-        u8_from_field_unsafe(a_3_bits[6] + 2 * a_3_bits[7] + 4 * a_0_bits[0] + 8 * a_0_bits[1] + 16 * a_0_bits[2] + 32 * a_0_bits[3] + 64 * a_0_bits[4] + 128 * a_0_bits[5]),
-        u8_from_field_unsafe(a_2_bits[6] + 2 * a_2_bits[7] + 4 * a_3_bits[0] + 8 * a_3_bits[1] + 16 * a_3_bits[2] + 32 * a_3_bits[3] + 64 * a_3_bits[4] + 128 * a_3_bits[5])
-      ];
-
-      let s0 = [
-        u8_xor(a_rotr2[0], u8_xor(a_rotr13[0], a_rotr22[0])),
-        u8_xor(a_rotr2[1], u8_xor(a_rotr13[1], a_rotr22[1])),
-        u8_xor(a_rotr2[2], u8_xor(a_rotr13[2], a_rotr22[2])),
-        u8_xor(a_rotr2[3], u8_xor(a_rotr13[3], a_rotr22[3]))
-      ];
-      let maj = [
-        u8_xor(u8_and(acc[0][0], acc[1][0]), u8_xor(u8_and(acc[0][0], acc[2][0]), u8_and(acc[1][0], acc[2][0]))),
-        u8_xor(u8_and(acc[0][1], acc[1][1]), u8_xor(u8_and(acc[0][1], acc[2][1]), u8_and(acc[1][1], acc[2][1]))),
-        u8_xor(u8_and(acc[0][2], acc[1][2]), u8_xor(u8_and(acc[0][2], acc[2][2]), u8_and(acc[1][2], acc[2][2]))),
-        u8_xor(u8_and(acc[0][3], acc[1][3]), u8_xor(u8_and(acc[0][3], acc[2][3]), u8_and(acc[1][3], acc[2][3])))
-      ];
-      -- temp2 = s0 ⊞ maj
-      let (t20, t2c1) = u8_add(s0[3], maj[3]);
-      let (t2t1, t2o1) = u8_add(s0[2], maj[2]);
-      let (t21, t2c1a) = u8_add(t2t1, t2c1);
-      let t2c2 = u8_from_field_unsafe(to_field(t2o1) + to_field(t2c1a));
-      let (t2t2, t2o2) = u8_add(s0[1], maj[1]);
-      let (t22, t2c2a) = u8_add(t2t2, t2c2);
-      let t2c3 = u8_from_field_unsafe(to_field(t2o2) + to_field(t2c2a));
-      let (t2t3, _x) = u8_add(s0[0], maj[0]);
-      let (t23, _x) = u8_add(t2t3, t2c3);
-
-      -- a' = temp1 ⊞ temp2
-      let (na0, nac1) = u8_add(t10, t20);
-      let (nat1, nao1) = u8_add(t11, t21);
-      let (na1, nac1a) = u8_add(nat1, nac1);
-      let nac2 = u8_from_field_unsafe(to_field(nao1) + to_field(nac1a));
-      let (nat2, nao2) = u8_add(t12, t22);
-      let (na2, nac2a) = u8_add(nat2, nac2);
-      let nac3 = u8_from_field_unsafe(to_field(nao2) + to_field(nac2a));
-      let (nat3, _x) = u8_add(t13, t23);
-      let (na3, _x) = u8_add(nat3, nac3);
-
-      -- e' = d ⊞ temp1
-      let (ne0, nec1) = u8_add(acc[3][3], t10);
-      let (net1, neo1) = u8_add(acc[3][2], t11);
-      let (ne1, nec1a) = u8_add(net1, nec1);
-      let nec2 = u8_from_field_unsafe(to_field(neo1) + to_field(nec1a));
-      let (net2, neo2) = u8_add(acc[3][1], t12);
-      let (ne2, nec2a) = u8_add(net2, nec2);
-      let nec3 = u8_from_field_unsafe(to_field(neo2) + to_field(nec2a));
-      let (net3, _x) = u8_add(acc[3][0], t13);
-      let (ne3, _x) = u8_add(net3, nec3);
-
-      [[na3, na2, na1, na0], acc[0], acc[1], acc[2], [ne3, ne2, ne1, ne0], acc[4], acc[5], acc[6]]
+      let s1 = @big_sigma1(acc[4]);
+      let ch_efg = @ch(acc[4], acc[5], acc[6]);
+      let temp1 = @u32_be_add(acc[7], @u32_be_add(s1, @u32_be_add(ch_efg, @u32_be_add(ki, wi))));
+      let s0 = @big_sigma0(acc[0]);
+      let maj_abc = @maj(acc[0], acc[1], acc[2]);
+      let temp2 = @u32_be_add(s0, maj_abc);
+      [@u32_be_add(temp1, temp2), acc[0], acc[1], acc[2],
+       @u32_be_add(acc[3], temp1), acc[4], acc[5], acc[6]]
     );
 
-    -- Final Davies-Meyer state addition, inlined per word via the same
-    -- big-endian u8_add carry chains as the round body.
     let fs = fold(0 .. 8, [[0u8; 4]; 8], |fs, @j|
       let sw = state[@j];
       let nw = state_new[@j];
-      let (f0, fc1) = u8_add(sw[3], nw[3]);
-      let (ft1, fo1) = u8_add(sw[2], nw[2]);
-      let (f1, fc1a) = u8_add(ft1, fc1);
-      let fc2 = u8_from_field_unsafe(to_field(fo1) + to_field(fc1a));
-      let (ft2, fo2) = u8_add(sw[1], nw[1]);
-      let (f2, fc2a) = u8_add(ft2, fc2);
-      let fc3 = u8_from_field_unsafe(to_field(fo2) + to_field(fc2a));
-      let (ft3, _x) = u8_add(sw[0], nw[0]);
-      let (f3, _x) = u8_add(ft3, fc3);
-      set(fs, @j, [f3, f2, f1, f0])
+      set(fs, @j, @u32_be_add(sw, nw))
     );
     fs
   }

From 0081ba94d6b1fa1d50889230b1c4085a1da08009 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sun, 12 Jul 2026 17:48:09 -0700
Subject: [PATCH 06/22] sha256: compute ch/maj final combine with free field
 adds

`ch` and `maj` xor bitwise-disjoint terms, so the xors are free field adds
(no u8_xor lookup): ch = (e&f) + (~e&g); maj = (a&b) + (c & (a^b)) with
a^b = (a+b) - 2(a&b) recomposed for free. Two u32_ands each instead of
ch's 2-and+1-xor and maj's 3-and+2-xor. Sums stay <= 255 (disjointness),
so u8_from_field_unsafe is sound.

Cuts fill_W_and_run_rounds by 1024 lookups (8889 -> 7865), width 33038 ->
29966 (-9.3%); sha256_bench total FFT 5,906,938 -> 5,395,557 (-8.7%).
Digests verified against the Rust reference across padding-boundary sizes.
---
 Ix/IxVM/Sha256.lean | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/Ix/IxVM/Sha256.lean b/Ix/IxVM/Sha256.lean
index 82469d02..28f9a89b 100644
--- a/Ix/IxVM/Sha256.lean
+++ b/Ix/IxVM/Sha256.lean
@@ -626,14 +626,32 @@ def sha256 := ⟦
      u8_from_field_unsafe(255 - to_field(a[2])), u8_from_field_unsafe(255 - to_field(a[3]))]
   }
 
-  -- ch = (e & f) ^ (~e & g).
+  -- ch = (e & f) ^ (~e & g). The two ands are bitwise-disjoint (one needs the
+  -- e bit set, the other clear), so the xor is a free field add (no lookup).
   fn ch(e: [U8; 4], f: [U8; 4], g: [U8; 4]) -> [U8; 4] {
-    @u32_xor(@u32_and(e, f), @u32_and(@u32_not(e), g))
+    let ef = @u32_and(e, f);
+    let neg = @u32_and(@u32_not(e), g);
+    [u8_from_field_unsafe(to_field(ef[0]) + to_field(neg[0])),
+     u8_from_field_unsafe(to_field(ef[1]) + to_field(neg[1])),
+     u8_from_field_unsafe(to_field(ef[2]) + to_field(neg[2])),
+     u8_from_field_unsafe(to_field(ef[3]) + to_field(neg[3]))]
   }
 
-  -- maj = (a & b) ^ (a & c) ^ (b & c).
+  -- maj = (a & b) ^ (a & c) ^ (b & c) = (a & b) + (c & (a ^ b)). `a ^ b` is the
+  -- free recomposition (a + b) - 2·(a & b); the two final terms are disjoint
+  -- (a = b ⇒ second is 0, a ≠ b ⇒ first is 0), so their xor is a free add too.
+  -- Two ands instead of three ands + two xors.
   fn maj(a: [U8; 4], b: [U8; 4], c: [U8; 4]) -> [U8; 4] {
-    @u32_xor(@u32_and(a, b), @u32_xor(@u32_and(a, c), @u32_and(b, c)))
+    let ab = @u32_and(a, b);
+    let axb = [u8_from_field_unsafe((to_field(a[0]) + to_field(b[0])) - 2 * to_field(ab[0])),
+               u8_from_field_unsafe((to_field(a[1]) + to_field(b[1])) - 2 * to_field(ab[1])),
+               u8_from_field_unsafe((to_field(a[2]) + to_field(b[2])) - 2 * to_field(ab[2])),
+               u8_from_field_unsafe((to_field(a[3]) + to_field(b[3])) - 2 * to_field(ab[3]))];
+    let cx = @u32_and(c, axb);
+    [u8_from_field_unsafe(to_field(ab[0]) + to_field(cx[0])),
+     u8_from_field_unsafe(to_field(ab[1]) + to_field(cx[1])),
+     u8_from_field_unsafe(to_field(ab[2]) + to_field(cx[2])),
+     u8_from_field_unsafe(to_field(ab[3]) + to_field(cx[3]))]
   }
 
   -- The four SHA-256 sigmas. Each decomposes its word's bytes ONCE (b0 =

From cb4023b279f1f1bf5c241590c836dbd0eb6f7972 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sun, 12 Jul 2026 18:01:03 -0700
Subject: [PATCH 07/22] sha256: fuse multi-word additions into one carry pass

The round's temp1 = h + Sigma1 + ch + K + W (5 words) and the schedule's
W_i = W_16 + sigma0 + W_7 + sigma1 (4 words) were chained `u32_be_add`s,
re-propagating carries each step. `u32_be_add4`/`u32_be_add5` accumulate
each byte column with chained `u8_add` (partial stays < 256) and fold the
0/1 carry bits into the next column with a free field add: 15 u8_adds vs
21 for a 4-word sum, 19 vs 28 for a 5-word sum. Column carry is
floor(sum/256) <= 4, safe to feed back to `u8_add`.

fill_W_and_run_rounds lookups 7865 -> 7001, width 29966 -> 27374;
sha256_bench total FFT 5,395,557 -> 4,964,080. With the ch/maj change,
sha256 FFT is down 16% from 5,906,938. Digests verified across
padding-boundary sizes.
---
 Ix/IxVM/Sha256.lean | 60 +++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 58 insertions(+), 2 deletions(-)

diff --git a/Ix/IxVM/Sha256.lean b/Ix/IxVM/Sha256.lean
index 28f9a89b..da630a74 100644
--- a/Ix/IxVM/Sha256.lean
+++ b/Ix/IxVM/Sha256.lean
@@ -613,6 +613,62 @@ def sha256 := ⟦
     [s3, s2, s1, s0]
   }
 
+  -- Big-endian sum of four 32-bit words in one carry-propagation pass. Each
+  -- byte column is accumulated with chained `u8_add` (running partial stays
+  -- < 256); the 0/1 carry bits fold into the next column with a free field
+  -- add. 15 `u8_add`s vs 21 for three chained `u32_be_add`s. The column carry
+  -- is floor(column_sum / 256) <= 3 (< 256), so feeding it to `u8_add` is safe.
+  fn u32_be_add4(a: [U8; 4], b: [U8; 4], c: [U8; 4], d: [U8; 4]) -> [U8; 4] {
+    let (t, k1) = u8_add(a[3], b[3]);
+    let (t, k2) = u8_add(t, c[3]);
+    let (s0, k3) = u8_add(t, d[3]);
+    let cy = u8_from_field_unsafe(to_field(k1) + to_field(k2) + to_field(k3));
+    let (t, k1) = u8_add(a[2], b[2]);
+    let (t, k2) = u8_add(t, c[2]);
+    let (t, k3) = u8_add(t, d[2]);
+    let (s1, k4) = u8_add(t, cy);
+    let cy = u8_from_field_unsafe(to_field(k1) + to_field(k2) + to_field(k3) + to_field(k4));
+    let (t, k1) = u8_add(a[1], b[1]);
+    let (t, k2) = u8_add(t, c[1]);
+    let (t, k3) = u8_add(t, d[1]);
+    let (s2, k4) = u8_add(t, cy);
+    let cy = u8_from_field_unsafe(to_field(k1) + to_field(k2) + to_field(k3) + to_field(k4));
+    let (t, _x) = u8_add(a[0], b[0]);
+    let (t, _x) = u8_add(t, c[0]);
+    let (t, _x) = u8_add(t, d[0]);
+    let (s3, _x) = u8_add(t, cy);
+    [s3, s2, s1, s0]
+  }
+
+  -- Big-endian sum of five 32-bit words in one carry pass (as `u32_be_add4`).
+  -- 19 `u8_add`s vs 28 for four chained `u32_be_add`s. Column carry is
+  -- floor(column_sum / 256) <= 4 (< 256).
+  fn u32_be_add5(a: [U8; 4], b: [U8; 4], c: [U8; 4], d: [U8; 4], e: [U8; 4]) -> [U8; 4] {
+    let (t, k1) = u8_add(a[3], b[3]);
+    let (t, k2) = u8_add(t, c[3]);
+    let (t, k3) = u8_add(t, d[3]);
+    let (s0, k4) = u8_add(t, e[3]);
+    let cy = u8_from_field_unsafe(to_field(k1) + to_field(k2) + to_field(k3) + to_field(k4));
+    let (t, k1) = u8_add(a[2], b[2]);
+    let (t, k2) = u8_add(t, c[2]);
+    let (t, k3) = u8_add(t, d[2]);
+    let (t, k4) = u8_add(t, e[2]);
+    let (s1, k5) = u8_add(t, cy);
+    let cy = u8_from_field_unsafe(to_field(k1) + to_field(k2) + to_field(k3) + to_field(k4) + to_field(k5));
+    let (t, k1) = u8_add(a[1], b[1]);
+    let (t, k2) = u8_add(t, c[1]);
+    let (t, k3) = u8_add(t, d[1]);
+    let (t, k4) = u8_add(t, e[1]);
+    let (s2, k5) = u8_add(t, cy);
+    let cy = u8_from_field_unsafe(to_field(k1) + to_field(k2) + to_field(k3) + to_field(k4) + to_field(k5));
+    let (t, _x) = u8_add(a[0], b[0]);
+    let (t, _x) = u8_add(t, c[0]);
+    let (t, _x) = u8_add(t, d[0]);
+    let (t, _x) = u8_add(t, e[0]);
+    let (s3, _x) = u8_add(t, cy);
+    [s3, s2, s1, s0]
+  }
+
   fn u32_xor(a: [U8; 4], b: [U8; 4]) -> [U8; 4] {
     [u8_xor(a[0], b[0]), u8_xor(a[1], b[1]), u8_xor(a[2], b[2]), u8_xor(a[3], b[3])]
   }
@@ -803,7 +859,7 @@ def sha256 := ⟦
       let w7 = Wx[@i - 7];
       let s0 = @small_sigma0(w15);
       let s1 = @small_sigma1(w2);
-      set(Wx, @i, @u32_be_add(w16, @u32_be_add(s0, @u32_be_add(w7, s1))))
+      set(Wx, @i, @u32_be_add4(w16, s0, w7, s1))
     );
     let W = Wx;
 
@@ -813,7 +869,7 @@ def sha256 := ⟦
       let wi = W[@i];
       let s1 = @big_sigma1(acc[4]);
       let ch_efg = @ch(acc[4], acc[5], acc[6]);
-      let temp1 = @u32_be_add(acc[7], @u32_be_add(s1, @u32_be_add(ch_efg, @u32_be_add(ki, wi))));
+      let temp1 = @u32_be_add5(acc[7], s1, ch_efg, ki, wi);
       let s0 = @big_sigma0(acc[0]);
       let maj_abc = @maj(acc[0], acc[1], acc[2]);
       let temp2 = @u32_be_add(s0, maj_abc);

From a9389f1e2c3112ddf5c0e3fdd49967f913d8318c Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Mon, 13 Jul 2026 01:48:09 -0700
Subject: [PATCH 08/22] sha256: call the round and schedule instead of inlining
 64x

fill_W_and_run_rounds inlined the 64-round compression and 48-word message
schedule into one 27,374-column circuit -- the same pathological trace
width as keccak's inlined permutation. Factor out `sha256_round` and
`sha256_schedule` as calls (their sigma/ch/maj/add helpers stay inlined),
so the rounds/words share narrow circuits run as rows.

fill_W_and_run_rounds 27,374 -> 2,734 wide (sha256_round 342, schedule
192); total committed width 28,153 -> 4,047 (7x smaller). FFT proxy rises
4.96M -> 12.07M (over-weights the taller trace) but real proving is much
faster: sha256_bench average throughput 4.59 -> 7.74 KiB/s (+68%). Digests
verified against the Rust reference across padding-boundary sizes.
---
 Ix/IxVM/Sha256.lean | 36 +++++++++++++++++++++++++-----------
 1 file changed, 25 insertions(+), 11 deletions(-)

diff --git a/Ix/IxVM/Sha256.lean b/Ix/IxVM/Sha256.lean
index da630a74..695f8828 100644
--- a/Ix/IxVM/Sha256.lean
+++ b/Ix/IxVM/Sha256.lean
@@ -825,6 +825,29 @@ def sha256 := ⟦
      u8_xor(r17[3], u8_xor(r19[3], s10[2]))]
   }
 
+  -- One message-schedule word: W_i = W_16 + sigma0(W_15) + W_7 + sigma1(W_2).
+  -- A call (not `@`-inlined) so the 48 schedule words share one circuit
+  -- instead of widening the block circuit 48-fold.
+  fn sha256_schedule(w16: [U8; 4], w15: [U8; 4], w7: [U8; 4], w2: [U8; 4]) -> [U8; 4] {
+    let s0 = @small_sigma0(w15);
+    let s1 = @small_sigma1(w2);
+    @u32_be_add4(w16, s0, w7, s1)
+  }
+
+  -- One compression round. Called (not `@`-inlined) so the 64 rounds share
+  -- one circuit run as 64 rows, keeping the block circuit narrow -- the
+  -- sigma/ch/maj/add helpers stay inlined within this round.
+  fn sha256_round(acc: [[U8; 4]; 8], ki: [U8; 4], wi: [U8; 4]) -> [[U8; 4]; 8] {
+    let s1 = @big_sigma1(acc[4]);
+    let ch_efg = @ch(acc[4], acc[5], acc[6]);
+    let temp1 = @u32_be_add5(acc[7], s1, ch_efg, ki, wi);
+    let s0 = @big_sigma0(acc[0]);
+    let maj_abc = @maj(acc[0], acc[1], acc[2]);
+    let temp2 = @u32_be_add(s0, maj_abc);
+    [@u32_be_add(temp1, temp2), acc[0], acc[1], acc[2],
+     @u32_be_add(acc[3], temp1), acc[4], acc[5], acc[6]]
+  }
+
   fn fill_W_and_run_rounds(W: [[U8; 4]; 16], state: [[U8; 4]; 8]) -> [[U8; 4]; 8] {
     let K = [
       [0x42u8, 0x8au8, 0x2fu8, 0x98u8], [0x71u8, 0x37u8, 0x44u8, 0x91u8], [0xb5u8, 0xc0u8, 0xfbu8, 0xcfu8], [0xe9u8, 0xb5u8, 0xdbu8, 0xa5u8],
@@ -857,9 +880,7 @@ def sha256 := ⟦
       let w2 = Wx[@i - 2];
       let w16 = Wx[@i - 16];
       let w7 = Wx[@i - 7];
-      let s0 = @small_sigma0(w15);
-      let s1 = @small_sigma1(w2);
-      set(Wx, @i, @u32_be_add4(w16, s0, w7, s1))
+      set(Wx, @i, sha256_schedule(w16, w15, w7, w2))
     );
     let W = Wx;
 
@@ -867,14 +888,7 @@ def sha256 := ⟦
       -- acc = [a,b,c,d,e,f,g,h]; K[i], W[i] are the round constant and word.
       let ki = K[@i];
       let wi = W[@i];
-      let s1 = @big_sigma1(acc[4]);
-      let ch_efg = @ch(acc[4], acc[5], acc[6]);
-      let temp1 = @u32_be_add5(acc[7], s1, ch_efg, ki, wi);
-      let s0 = @big_sigma0(acc[0]);
-      let maj_abc = @maj(acc[0], acc[1], acc[2]);
-      let temp2 = @u32_be_add(s0, maj_abc);
-      [@u32_be_add(temp1, temp2), acc[0], acc[1], acc[2],
-       @u32_be_add(acc[3], temp1), acc[4], acc[5], acc[6]]
+      sha256_round(acc, ki, wi)
     );
 
     let fs = fold(0 .. 8, [[0u8; 4]; 8], |fs, @j|

From 064aeee8caf0e1b1b52d51b35c69e1841bce4237 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sat, 11 Jul 2026 07:56:45 -0700
Subject: [PATCH 09/22] Aiur keccak-256: value-based IxVM implementation, 78x
 cheaper
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Ix/MultiStark/Keccak.lean optimizes for circuit narrowness, which the
FFT cost model (width x height x log2(height)) punishes: lanes live
behind pointers (3 memory lookups per xor8 call), every word op is a
helper-circuit call, each rotation builds a 64-node linked bit list
walked with per-bit list_drops, and keccak_round runs as a separate
circuit 24x per permutation. Probed at 1 hash over 2048 bytes of
non-periodic LCG data: 1,415,128,681 total FFT — 85% of it list_drop /
build_rot / memory[3] rows.

Ix/IxVM/Keccak.lean reshapes it for the model: lanes and the 25-lane
state are plain values, word ops are inline u8 byte ops, rho+pi
rotations are static recompositions (decompose bytes once, recompose
at compile-time bit offsets; multiples-of-8 rotations are free byte
shuffles), theta's rotl-by-1 needs no decomposition at all
(`u8_add(b, b)` = (2b mod 256, msb), the even low byte absorbs the
neighbor's carry via free field add), and iota indexes a constant RC
table. Each round runs as two circuits (theta | rho+pi+chi+iota) of
height 24 x permutations — a single fully-unrolled permutation
circuit is cheaper still on paper, but its macro-expanded body
overflows the Lean elaborator stack (as do 8-name array-destructure
patterns at scale, hence bits are indexed from array-bound
decompositions). The rho+pi wiring is generated programmatically and
asserted against the MultiStark listing.

Same probe: 18,105,233 total FFT (-98.7%, 78x). New `aiur-hashes`
cases pin correctness against the Rust FFI oracle (Keccak.hash) at
the rate boundaries 0/1/32/135/136/137/271/272/273/1200 — execute,
claim, and prove/verify all green.
---
 Ix/IxVM/Keccak.lean    | 809 +++++++++++++++++++++++++++++++++++++++++
 Tests/Aiur/Hashes.lean |  29 ++
 Tests/Main.lean        |   6 +-
 3 files changed, 843 insertions(+), 1 deletion(-)
 create mode 100644 Ix/IxVM/Keccak.lean

diff --git a/Ix/IxVM/Keccak.lean b/Ix/IxVM/Keccak.lean
new file mode 100644
index 00000000..694abd5a
--- /dev/null
+++ b/Ix/IxVM/Keccak.lean
@@ -0,0 +1,809 @@
+module
+public import Ix.Aiur.Meta
+
+/-!
+# Keccak-256 in Aiur (value-based, wide permutation circuit)
+
+Same algorithm/variant as `Ix/MultiStark/Keccak.lean` (Ethereum keccak-256:
+pad `10*1`, rate 136, capacity 512) but shaped for the FFT cost model
+(width x height x log2(height)): lanes and the 25-lane state are plain
+values (no pointers, no memory traffic), the 24 rounds unroll into ONE
+permutation circuit via `fold` (one row per keccak-f call), and rotations
+are static bit recompositions (decompose once, recompose at compile-time
+offsets) instead of runtime bit lists. theta's rotl-by-1 skips
+decomposition entirely: `u8_add(b, b)` yields `(2b mod 256, msb)` and the
+even low byte absorbs the neighbor's carry with a free field add.
+
+Generated by a script (rho+pi is 24 distinct static bit wirings); the
+pi/rho wiring is asserted against the MultiStark listing at generation
+time.
+-/
+
+public section
+
+namespace IxVM
+
+-- The unrolled 24-round permutation elaborates to one deeply nested let
+-- chain; the default recursion budget is not enough.
+set_option maxRecDepth 65536 in
+def keccak := ⟦
+  /- # Test entrypoints -/
+
+  pub fn keccak256_test() -> [[U8; 8]; 4] {
+    let (idx, len) = io_get_info(0, [0]);
+    let byte_stream = #read_byte_stream(0, idx, len);
+    keccak256(byte_stream)
+  }
+
+  /- # Benchmark entrypoints -/
+
+  pub fn keccak256_bench(num_hashes: G) -> G {
+    let num_hashes_pred = num_hashes - 1;
+    let key = [num_hashes_pred];
+    let (idx, len) = io_get_info(0, key);
+    let byte_stream = #read_byte_stream(0, idx, len);
+    keccak256(byte_stream);
+    match num_hashes_pred {
+      0 => 0,
+      _ => keccak256_bench(num_hashes_pred),
+    }
+  }
+
+  /- # Sponge -/
+
+  -- Pad bytes for positions i..135 once the message is exhausted: `first`
+  -- is 1 on the first pad position (0x01 bit), position 135 carries the
+  -- 0x80 bit (0x81 when both land on 135).
+  fn build_pad(i: G, first: G) -> ByteStream {
+    match 136 - i {
+      0 => store(ListNode.Nil),
+      _ =>
+        store(ListNode.Cons(u8_from_field_unsafe(first + 128 * eq_zero(135 - i)),
+                            build_pad(i + 1, 0))),
+    }
+  }
+
+  -- Take one 136-byte rate block from `stream` starting at position `i`.
+  -- Returns (block, rest, full): full=1 iff 136 message bytes were consumed
+  -- (padding not yet applied). An empty stream yields the all-padding block
+  -- keccak appends when the message length is a multiple of 136.
+  fn read_block(stream: ByteStream, i: G) -> (ByteStream, ByteStream, G) {
+    match 136 - i {
+      0 => (store(ListNode.Nil), stream, 1),
+      _ => match load(stream) {
+        ListNode.Cons(b, rest) =>
+          let (blk, r, f) = read_block(rest, i + 1);
+          (store(ListNode.Cons(b, blk)), r, f),
+        ListNode.Nil => (build_pad(i, 1), store(ListNode.Nil), 0),
+      },
+    }
+  }
+
+  -- Extract lane bytes [b .. b+7] from the rate block (one `list_drop` to
+  -- the first byte; the rest are successive tails).
+  fn rate_lane(rate: ByteStream, b: G) -> [U8; 8] {
+    let &ListNode.Cons(r0, t0) = list_drop(rate, b);
+    let &ListNode.Cons(r1, t1) = t0;
+    let &ListNode.Cons(r2, t2) = t1;
+    let &ListNode.Cons(r3, t3) = t2;
+    let &ListNode.Cons(r4, t4) = t3;
+    let &ListNode.Cons(r5, t5) = t4;
+    let &ListNode.Cons(r6, t6) = t5;
+    let &ListNode.Cons(r7, _) = t6;
+    [r0, r1, r2, r3, r4, r5, r6, r7]
+  }
+
+  -- XOR one 136-byte rate block into the first 17 lanes, then permute.
+  fn absorb_one(s: [[U8; 8]; 25], rate: ByteStream) -> [[U8; 8]; 25] {
+    let rl0 = rate_lane(rate, 0);
+    let rl1 = rate_lane(rate, 8);
+    let rl2 = rate_lane(rate, 16);
+    let rl3 = rate_lane(rate, 24);
+    let rl4 = rate_lane(rate, 32);
+    let rl5 = rate_lane(rate, 40);
+    let rl6 = rate_lane(rate, 48);
+    let rl7 = rate_lane(rate, 56);
+    let rl8 = rate_lane(rate, 64);
+    let rl9 = rate_lane(rate, 72);
+    let rl10 = rate_lane(rate, 80);
+    let rl11 = rate_lane(rate, 88);
+    let rl12 = rate_lane(rate, 96);
+    let rl13 = rate_lane(rate, 104);
+    let rl14 = rate_lane(rate, 112);
+    let rl15 = rate_lane(rate, 120);
+    let rl16 = rate_lane(rate, 128);
+    let s = set(s, 0, [u8_xor(s[0][0], rl0[0]), u8_xor(s[0][1], rl0[1]), u8_xor(s[0][2], rl0[2]), u8_xor(s[0][3], rl0[3]), u8_xor(s[0][4], rl0[4]), u8_xor(s[0][5], rl0[5]), u8_xor(s[0][6], rl0[6]), u8_xor(s[0][7], rl0[7])]);
+    let s = set(s, 1, [u8_xor(s[1][0], rl1[0]), u8_xor(s[1][1], rl1[1]), u8_xor(s[1][2], rl1[2]), u8_xor(s[1][3], rl1[3]), u8_xor(s[1][4], rl1[4]), u8_xor(s[1][5], rl1[5]), u8_xor(s[1][6], rl1[6]), u8_xor(s[1][7], rl1[7])]);
+    let s = set(s, 2, [u8_xor(s[2][0], rl2[0]), u8_xor(s[2][1], rl2[1]), u8_xor(s[2][2], rl2[2]), u8_xor(s[2][3], rl2[3]), u8_xor(s[2][4], rl2[4]), u8_xor(s[2][5], rl2[5]), u8_xor(s[2][6], rl2[6]), u8_xor(s[2][7], rl2[7])]);
+    let s = set(s, 3, [u8_xor(s[3][0], rl3[0]), u8_xor(s[3][1], rl3[1]), u8_xor(s[3][2], rl3[2]), u8_xor(s[3][3], rl3[3]), u8_xor(s[3][4], rl3[4]), u8_xor(s[3][5], rl3[5]), u8_xor(s[3][6], rl3[6]), u8_xor(s[3][7], rl3[7])]);
+    let s = set(s, 4, [u8_xor(s[4][0], rl4[0]), u8_xor(s[4][1], rl4[1]), u8_xor(s[4][2], rl4[2]), u8_xor(s[4][3], rl4[3]), u8_xor(s[4][4], rl4[4]), u8_xor(s[4][5], rl4[5]), u8_xor(s[4][6], rl4[6]), u8_xor(s[4][7], rl4[7])]);
+    let s = set(s, 5, [u8_xor(s[5][0], rl5[0]), u8_xor(s[5][1], rl5[1]), u8_xor(s[5][2], rl5[2]), u8_xor(s[5][3], rl5[3]), u8_xor(s[5][4], rl5[4]), u8_xor(s[5][5], rl5[5]), u8_xor(s[5][6], rl5[6]), u8_xor(s[5][7], rl5[7])]);
+    let s = set(s, 6, [u8_xor(s[6][0], rl6[0]), u8_xor(s[6][1], rl6[1]), u8_xor(s[6][2], rl6[2]), u8_xor(s[6][3], rl6[3]), u8_xor(s[6][4], rl6[4]), u8_xor(s[6][5], rl6[5]), u8_xor(s[6][6], rl6[6]), u8_xor(s[6][7], rl6[7])]);
+    let s = set(s, 7, [u8_xor(s[7][0], rl7[0]), u8_xor(s[7][1], rl7[1]), u8_xor(s[7][2], rl7[2]), u8_xor(s[7][3], rl7[3]), u8_xor(s[7][4], rl7[4]), u8_xor(s[7][5], rl7[5]), u8_xor(s[7][6], rl7[6]), u8_xor(s[7][7], rl7[7])]);
+    let s = set(s, 8, [u8_xor(s[8][0], rl8[0]), u8_xor(s[8][1], rl8[1]), u8_xor(s[8][2], rl8[2]), u8_xor(s[8][3], rl8[3]), u8_xor(s[8][4], rl8[4]), u8_xor(s[8][5], rl8[5]), u8_xor(s[8][6], rl8[6]), u8_xor(s[8][7], rl8[7])]);
+    let s = set(s, 9, [u8_xor(s[9][0], rl9[0]), u8_xor(s[9][1], rl9[1]), u8_xor(s[9][2], rl9[2]), u8_xor(s[9][3], rl9[3]), u8_xor(s[9][4], rl9[4]), u8_xor(s[9][5], rl9[5]), u8_xor(s[9][6], rl9[6]), u8_xor(s[9][7], rl9[7])]);
+    let s = set(s, 10, [u8_xor(s[10][0], rl10[0]), u8_xor(s[10][1], rl10[1]), u8_xor(s[10][2], rl10[2]), u8_xor(s[10][3], rl10[3]), u8_xor(s[10][4], rl10[4]), u8_xor(s[10][5], rl10[5]), u8_xor(s[10][6], rl10[6]), u8_xor(s[10][7], rl10[7])]);
+    let s = set(s, 11, [u8_xor(s[11][0], rl11[0]), u8_xor(s[11][1], rl11[1]), u8_xor(s[11][2], rl11[2]), u8_xor(s[11][3], rl11[3]), u8_xor(s[11][4], rl11[4]), u8_xor(s[11][5], rl11[5]), u8_xor(s[11][6], rl11[6]), u8_xor(s[11][7], rl11[7])]);
+    let s = set(s, 12, [u8_xor(s[12][0], rl12[0]), u8_xor(s[12][1], rl12[1]), u8_xor(s[12][2], rl12[2]), u8_xor(s[12][3], rl12[3]), u8_xor(s[12][4], rl12[4]), u8_xor(s[12][5], rl12[5]), u8_xor(s[12][6], rl12[6]), u8_xor(s[12][7], rl12[7])]);
+    let s = set(s, 13, [u8_xor(s[13][0], rl13[0]), u8_xor(s[13][1], rl13[1]), u8_xor(s[13][2], rl13[2]), u8_xor(s[13][3], rl13[3]), u8_xor(s[13][4], rl13[4]), u8_xor(s[13][5], rl13[5]), u8_xor(s[13][6], rl13[6]), u8_xor(s[13][7], rl13[7])]);
+    let s = set(s, 14, [u8_xor(s[14][0], rl14[0]), u8_xor(s[14][1], rl14[1]), u8_xor(s[14][2], rl14[2]), u8_xor(s[14][3], rl14[3]), u8_xor(s[14][4], rl14[4]), u8_xor(s[14][5], rl14[5]), u8_xor(s[14][6], rl14[6]), u8_xor(s[14][7], rl14[7])]);
+    let s = set(s, 15, [u8_xor(s[15][0], rl15[0]), u8_xor(s[15][1], rl15[1]), u8_xor(s[15][2], rl15[2]), u8_xor(s[15][3], rl15[3]), u8_xor(s[15][4], rl15[4]), u8_xor(s[15][5], rl15[5]), u8_xor(s[15][6], rl15[6]), u8_xor(s[15][7], rl15[7])]);
+    let s = set(s, 16, [u8_xor(s[16][0], rl16[0]), u8_xor(s[16][1], rl16[1]), u8_xor(s[16][2], rl16[2]), u8_xor(s[16][3], rl16[3]), u8_xor(s[16][4], rl16[4]), u8_xor(s[16][5], rl16[5]), u8_xor(s[16][6], rl16[6]), u8_xor(s[16][7], rl16[7])]);
+    keccak_f(s)
+  }
+
+  -- Absorb every rate block of the (padded) message into the state.
+  fn absorb_blocks(stream: ByteStream, s: [[U8; 8]; 25]) -> [[U8; 8]; 25] {
+    let (block, rest, full) = read_block(stream, 0);
+    let s2 = absorb_one(s, block);
+    match full {
+      0 => s2,
+      _ => absorb_blocks(rest, s2),
+    }
+  }
+
+  -- keccak-256: absorb into the zero state, squeeze lanes 0..3.
+  fn keccak256(bytes: ByteStream) -> [[U8; 8]; 4] {
+    let s = absorb_blocks(bytes, [[0u8; 8]; 25]);
+    [s[0], s[1], s[2], s[3]]
+  }
+
+  /- # keccak-f[1600]: 24 unrolled rounds of theta-rho-pi-chi-iota -/
+
+  fn keccak_f(s: [[U8; 8]; 25]) -> [[U8; 8]; 25] {
+    let RC = [
+      [0x01u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
+      [0x82u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
+      [0x8au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
+      [0u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8],
+      [0x8bu8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
+      [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8],
+      [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8],
+      [0x09u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
+      [0x8au8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
+      [0x88u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
+      [0x09u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8],
+      [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8],
+      [0x8bu8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8],
+      [0x8bu8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
+      [0x89u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
+      [0x03u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
+      [0x02u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
+      [0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
+      [0x0au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
+      [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8],
+      [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8],
+      [0x80u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
+      [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8],
+      [0x08u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]
+    ];
+    fold(0 .. 24, s, |s, @i| keccak_rho_chi_iota(keccak_theta(s), RC[@i]))
+  }
+
+  -- One round, split into two circuits (theta | rho+pi+chi+iota), each of
+  -- height 24 x permutations. A single fully-unrolled permutation circuit
+  -- would be cheaper (no 200-column state re-input or 200 output aux per
+  -- call, one row per permutation at a 24x shorter height's log2), but its
+  -- ~7300-let macro-expanded body overflows the Lean elaborator's stack.
+  -- Building the Source.Term programmatically would unlock it.
+  fn keccak_theta(s: [[U8; 8]; 25]) -> [[U8; 8]; 25] {
+      -- theta: column parities C[x] = xor of the 5 lanes in column x.
+      let c0 = [
+        u8_xor(s[20][0], u8_xor(s[15][0], u8_xor(s[10][0], u8_xor(s[5][0], s[0][0])))),
+        u8_xor(s[20][1], u8_xor(s[15][1], u8_xor(s[10][1], u8_xor(s[5][1], s[0][1])))),
+        u8_xor(s[20][2], u8_xor(s[15][2], u8_xor(s[10][2], u8_xor(s[5][2], s[0][2])))),
+        u8_xor(s[20][3], u8_xor(s[15][3], u8_xor(s[10][3], u8_xor(s[5][3], s[0][3])))),
+        u8_xor(s[20][4], u8_xor(s[15][4], u8_xor(s[10][4], u8_xor(s[5][4], s[0][4])))),
+        u8_xor(s[20][5], u8_xor(s[15][5], u8_xor(s[10][5], u8_xor(s[5][5], s[0][5])))),
+        u8_xor(s[20][6], u8_xor(s[15][6], u8_xor(s[10][6], u8_xor(s[5][6], s[0][6])))),
+        u8_xor(s[20][7], u8_xor(s[15][7], u8_xor(s[10][7], u8_xor(s[5][7], s[0][7]))))
+      ];
+      let c1 = [
+        u8_xor(s[21][0], u8_xor(s[16][0], u8_xor(s[11][0], u8_xor(s[6][0], s[1][0])))),
+        u8_xor(s[21][1], u8_xor(s[16][1], u8_xor(s[11][1], u8_xor(s[6][1], s[1][1])))),
+        u8_xor(s[21][2], u8_xor(s[16][2], u8_xor(s[11][2], u8_xor(s[6][2], s[1][2])))),
+        u8_xor(s[21][3], u8_xor(s[16][3], u8_xor(s[11][3], u8_xor(s[6][3], s[1][3])))),
+        u8_xor(s[21][4], u8_xor(s[16][4], u8_xor(s[11][4], u8_xor(s[6][4], s[1][4])))),
+        u8_xor(s[21][5], u8_xor(s[16][5], u8_xor(s[11][5], u8_xor(s[6][5], s[1][5])))),
+        u8_xor(s[21][6], u8_xor(s[16][6], u8_xor(s[11][6], u8_xor(s[6][6], s[1][6])))),
+        u8_xor(s[21][7], u8_xor(s[16][7], u8_xor(s[11][7], u8_xor(s[6][7], s[1][7]))))
+      ];
+      let c2 = [
+        u8_xor(s[22][0], u8_xor(s[17][0], u8_xor(s[12][0], u8_xor(s[7][0], s[2][0])))),
+        u8_xor(s[22][1], u8_xor(s[17][1], u8_xor(s[12][1], u8_xor(s[7][1], s[2][1])))),
+        u8_xor(s[22][2], u8_xor(s[17][2], u8_xor(s[12][2], u8_xor(s[7][2], s[2][2])))),
+        u8_xor(s[22][3], u8_xor(s[17][3], u8_xor(s[12][3], u8_xor(s[7][3], s[2][3])))),
+        u8_xor(s[22][4], u8_xor(s[17][4], u8_xor(s[12][4], u8_xor(s[7][4], s[2][4])))),
+        u8_xor(s[22][5], u8_xor(s[17][5], u8_xor(s[12][5], u8_xor(s[7][5], s[2][5])))),
+        u8_xor(s[22][6], u8_xor(s[17][6], u8_xor(s[12][6], u8_xor(s[7][6], s[2][6])))),
+        u8_xor(s[22][7], u8_xor(s[17][7], u8_xor(s[12][7], u8_xor(s[7][7], s[2][7]))))
+      ];
+      let c3 = [
+        u8_xor(s[23][0], u8_xor(s[18][0], u8_xor(s[13][0], u8_xor(s[8][0], s[3][0])))),
+        u8_xor(s[23][1], u8_xor(s[18][1], u8_xor(s[13][1], u8_xor(s[8][1], s[3][1])))),
+        u8_xor(s[23][2], u8_xor(s[18][2], u8_xor(s[13][2], u8_xor(s[8][2], s[3][2])))),
+        u8_xor(s[23][3], u8_xor(s[18][3], u8_xor(s[13][3], u8_xor(s[8][3], s[3][3])))),
+        u8_xor(s[23][4], u8_xor(s[18][4], u8_xor(s[13][4], u8_xor(s[8][4], s[3][4])))),
+        u8_xor(s[23][5], u8_xor(s[18][5], u8_xor(s[13][5], u8_xor(s[8][5], s[3][5])))),
+        u8_xor(s[23][6], u8_xor(s[18][6], u8_xor(s[13][6], u8_xor(s[8][6], s[3][6])))),
+        u8_xor(s[23][7], u8_xor(s[18][7], u8_xor(s[13][7], u8_xor(s[8][7], s[3][7]))))
+      ];
+      let c4 = [
+        u8_xor(s[24][0], u8_xor(s[19][0], u8_xor(s[14][0], u8_xor(s[9][0], s[4][0])))),
+        u8_xor(s[24][1], u8_xor(s[19][1], u8_xor(s[14][1], u8_xor(s[9][1], s[4][1])))),
+        u8_xor(s[24][2], u8_xor(s[19][2], u8_xor(s[14][2], u8_xor(s[9][2], s[4][2])))),
+        u8_xor(s[24][3], u8_xor(s[19][3], u8_xor(s[14][3], u8_xor(s[9][3], s[4][3])))),
+        u8_xor(s[24][4], u8_xor(s[19][4], u8_xor(s[14][4], u8_xor(s[9][4], s[4][4])))),
+        u8_xor(s[24][5], u8_xor(s[19][5], u8_xor(s[14][5], u8_xor(s[9][5], s[4][5])))),
+        u8_xor(s[24][6], u8_xor(s[19][6], u8_xor(s[14][6], u8_xor(s[9][6], s[4][6])))),
+        u8_xor(s[24][7], u8_xor(s[19][7], u8_xor(s[14][7], u8_xor(s[9][7], s[4][7]))))
+      ];
+      -- rotl-by-1 of each C lane via the u8_add trick: (b + b) yields
+      -- (2b mod 256, msb); the even low byte absorbs the neighbor byte's
+      -- msb with a free field add.
+      let (l0_0, m0_0) = u8_add(c0[0], c0[0]);
+      let (l0_1, m0_1) = u8_add(c0[1], c0[1]);
+      let (l0_2, m0_2) = u8_add(c0[2], c0[2]);
+      let (l0_3, m0_3) = u8_add(c0[3], c0[3]);
+      let (l0_4, m0_4) = u8_add(c0[4], c0[4]);
+      let (l0_5, m0_5) = u8_add(c0[5], c0[5]);
+      let (l0_6, m0_6) = u8_add(c0[6], c0[6]);
+      let (l0_7, m0_7) = u8_add(c0[7], c0[7]);
+      let r0 = [u8_from_field_unsafe(to_field(l0_0) + to_field(m0_7)), u8_from_field_unsafe(to_field(l0_1) + to_field(m0_0)), u8_from_field_unsafe(to_field(l0_2) + to_field(m0_1)), u8_from_field_unsafe(to_field(l0_3) + to_field(m0_2)), u8_from_field_unsafe(to_field(l0_4) + to_field(m0_3)), u8_from_field_unsafe(to_field(l0_5) + to_field(m0_4)), u8_from_field_unsafe(to_field(l0_6) + to_field(m0_5)), u8_from_field_unsafe(to_field(l0_7) + to_field(m0_6))];
+      let (l1_0, m1_0) = u8_add(c1[0], c1[0]);
+      let (l1_1, m1_1) = u8_add(c1[1], c1[1]);
+      let (l1_2, m1_2) = u8_add(c1[2], c1[2]);
+      let (l1_3, m1_3) = u8_add(c1[3], c1[3]);
+      let (l1_4, m1_4) = u8_add(c1[4], c1[4]);
+      let (l1_5, m1_5) = u8_add(c1[5], c1[5]);
+      let (l1_6, m1_6) = u8_add(c1[6], c1[6]);
+      let (l1_7, m1_7) = u8_add(c1[7], c1[7]);
+      let r1 = [u8_from_field_unsafe(to_field(l1_0) + to_field(m1_7)), u8_from_field_unsafe(to_field(l1_1) + to_field(m1_0)), u8_from_field_unsafe(to_field(l1_2) + to_field(m1_1)), u8_from_field_unsafe(to_field(l1_3) + to_field(m1_2)), u8_from_field_unsafe(to_field(l1_4) + to_field(m1_3)), u8_from_field_unsafe(to_field(l1_5) + to_field(m1_4)), u8_from_field_unsafe(to_field(l1_6) + to_field(m1_5)), u8_from_field_unsafe(to_field(l1_7) + to_field(m1_6))];
+      let (l2_0, m2_0) = u8_add(c2[0], c2[0]);
+      let (l2_1, m2_1) = u8_add(c2[1], c2[1]);
+      let (l2_2, m2_2) = u8_add(c2[2], c2[2]);
+      let (l2_3, m2_3) = u8_add(c2[3], c2[3]);
+      let (l2_4, m2_4) = u8_add(c2[4], c2[4]);
+      let (l2_5, m2_5) = u8_add(c2[5], c2[5]);
+      let (l2_6, m2_6) = u8_add(c2[6], c2[6]);
+      let (l2_7, m2_7) = u8_add(c2[7], c2[7]);
+      let r2 = [u8_from_field_unsafe(to_field(l2_0) + to_field(m2_7)), u8_from_field_unsafe(to_field(l2_1) + to_field(m2_0)), u8_from_field_unsafe(to_field(l2_2) + to_field(m2_1)), u8_from_field_unsafe(to_field(l2_3) + to_field(m2_2)), u8_from_field_unsafe(to_field(l2_4) + to_field(m2_3)), u8_from_field_unsafe(to_field(l2_5) + to_field(m2_4)), u8_from_field_unsafe(to_field(l2_6) + to_field(m2_5)), u8_from_field_unsafe(to_field(l2_7) + to_field(m2_6))];
+      let (l3_0, m3_0) = u8_add(c3[0], c3[0]);
+      let (l3_1, m3_1) = u8_add(c3[1], c3[1]);
+      let (l3_2, m3_2) = u8_add(c3[2], c3[2]);
+      let (l3_3, m3_3) = u8_add(c3[3], c3[3]);
+      let (l3_4, m3_4) = u8_add(c3[4], c3[4]);
+      let (l3_5, m3_5) = u8_add(c3[5], c3[5]);
+      let (l3_6, m3_6) = u8_add(c3[6], c3[6]);
+      let (l3_7, m3_7) = u8_add(c3[7], c3[7]);
+      let r3 = [u8_from_field_unsafe(to_field(l3_0) + to_field(m3_7)), u8_from_field_unsafe(to_field(l3_1) + to_field(m3_0)), u8_from_field_unsafe(to_field(l3_2) + to_field(m3_1)), u8_from_field_unsafe(to_field(l3_3) + to_field(m3_2)), u8_from_field_unsafe(to_field(l3_4) + to_field(m3_3)), u8_from_field_unsafe(to_field(l3_5) + to_field(m3_4)), u8_from_field_unsafe(to_field(l3_6) + to_field(m3_5)), u8_from_field_unsafe(to_field(l3_7) + to_field(m3_6))];
+      let (l4_0, m4_0) = u8_add(c4[0], c4[0]);
+      let (l4_1, m4_1) = u8_add(c4[1], c4[1]);
+      let (l4_2, m4_2) = u8_add(c4[2], c4[2]);
+      let (l4_3, m4_3) = u8_add(c4[3], c4[3]);
+      let (l4_4, m4_4) = u8_add(c4[4], c4[4]);
+      let (l4_5, m4_5) = u8_add(c4[5], c4[5]);
+      let (l4_6, m4_6) = u8_add(c4[6], c4[6]);
+      let (l4_7, m4_7) = u8_add(c4[7], c4[7]);
+      let r4 = [u8_from_field_unsafe(to_field(l4_0) + to_field(m4_7)), u8_from_field_unsafe(to_field(l4_1) + to_field(m4_0)), u8_from_field_unsafe(to_field(l4_2) + to_field(m4_1)), u8_from_field_unsafe(to_field(l4_3) + to_field(m4_2)), u8_from_field_unsafe(to_field(l4_4) + to_field(m4_3)), u8_from_field_unsafe(to_field(l4_5) + to_field(m4_4)), u8_from_field_unsafe(to_field(l4_6) + to_field(m4_5)), u8_from_field_unsafe(to_field(l4_7) + to_field(m4_6))];
+      -- D[x] = C[x-1] ^ rotl1(C[x+1]); A'[x,y] = A[x,y] ^ D[x].
+      let d0 = [u8_xor(c4[0], r1[0]), u8_xor(c4[1], r1[1]), u8_xor(c4[2], r1[2]), u8_xor(c4[3], r1[3]), u8_xor(c4[4], r1[4]), u8_xor(c4[5], r1[5]), u8_xor(c4[6], r1[6]), u8_xor(c4[7], r1[7])];
+      let d1 = [u8_xor(c0[0], r2[0]), u8_xor(c0[1], r2[1]), u8_xor(c0[2], r2[2]), u8_xor(c0[3], r2[3]), u8_xor(c0[4], r2[4]), u8_xor(c0[5], r2[5]), u8_xor(c0[6], r2[6]), u8_xor(c0[7], r2[7])];
+      let d2 = [u8_xor(c1[0], r3[0]), u8_xor(c1[1], r3[1]), u8_xor(c1[2], r3[2]), u8_xor(c1[3], r3[3]), u8_xor(c1[4], r3[4]), u8_xor(c1[5], r3[5]), u8_xor(c1[6], r3[6]), u8_xor(c1[7], r3[7])];
+      let d3 = [u8_xor(c2[0], r4[0]), u8_xor(c2[1], r4[1]), u8_xor(c2[2], r4[2]), u8_xor(c2[3], r4[3]), u8_xor(c2[4], r4[4]), u8_xor(c2[5], r4[5]), u8_xor(c2[6], r4[6]), u8_xor(c2[7], r4[7])];
+      let d4 = [u8_xor(c3[0], r0[0]), u8_xor(c3[1], r0[1]), u8_xor(c3[2], r0[2]), u8_xor(c3[3], r0[3]), u8_xor(c3[4], r0[4]), u8_xor(c3[5], r0[5]), u8_xor(c3[6], r0[6]), u8_xor(c3[7], r0[7])];
+      let t0 = [u8_xor(s[0][0], d0[0]), u8_xor(s[0][1], d0[1]), u8_xor(s[0][2], d0[2]), u8_xor(s[0][3], d0[3]), u8_xor(s[0][4], d0[4]), u8_xor(s[0][5], d0[5]), u8_xor(s[0][6], d0[6]), u8_xor(s[0][7], d0[7])];
+      let t1 = [u8_xor(s[1][0], d1[0]), u8_xor(s[1][1], d1[1]), u8_xor(s[1][2], d1[2]), u8_xor(s[1][3], d1[3]), u8_xor(s[1][4], d1[4]), u8_xor(s[1][5], d1[5]), u8_xor(s[1][6], d1[6]), u8_xor(s[1][7], d1[7])];
+      let t2 = [u8_xor(s[2][0], d2[0]), u8_xor(s[2][1], d2[1]), u8_xor(s[2][2], d2[2]), u8_xor(s[2][3], d2[3]), u8_xor(s[2][4], d2[4]), u8_xor(s[2][5], d2[5]), u8_xor(s[2][6], d2[6]), u8_xor(s[2][7], d2[7])];
+      let t3 = [u8_xor(s[3][0], d3[0]), u8_xor(s[3][1], d3[1]), u8_xor(s[3][2], d3[2]), u8_xor(s[3][3], d3[3]), u8_xor(s[3][4], d3[4]), u8_xor(s[3][5], d3[5]), u8_xor(s[3][6], d3[6]), u8_xor(s[3][7], d3[7])];
+      let t4 = [u8_xor(s[4][0], d4[0]), u8_xor(s[4][1], d4[1]), u8_xor(s[4][2], d4[2]), u8_xor(s[4][3], d4[3]), u8_xor(s[4][4], d4[4]), u8_xor(s[4][5], d4[5]), u8_xor(s[4][6], d4[6]), u8_xor(s[4][7], d4[7])];
+      let t5 = [u8_xor(s[5][0], d0[0]), u8_xor(s[5][1], d0[1]), u8_xor(s[5][2], d0[2]), u8_xor(s[5][3], d0[3]), u8_xor(s[5][4], d0[4]), u8_xor(s[5][5], d0[5]), u8_xor(s[5][6], d0[6]), u8_xor(s[5][7], d0[7])];
+      let t6 = [u8_xor(s[6][0], d1[0]), u8_xor(s[6][1], d1[1]), u8_xor(s[6][2], d1[2]), u8_xor(s[6][3], d1[3]), u8_xor(s[6][4], d1[4]), u8_xor(s[6][5], d1[5]), u8_xor(s[6][6], d1[6]), u8_xor(s[6][7], d1[7])];
+      let t7 = [u8_xor(s[7][0], d2[0]), u8_xor(s[7][1], d2[1]), u8_xor(s[7][2], d2[2]), u8_xor(s[7][3], d2[3]), u8_xor(s[7][4], d2[4]), u8_xor(s[7][5], d2[5]), u8_xor(s[7][6], d2[6]), u8_xor(s[7][7], d2[7])];
+      let t8 = [u8_xor(s[8][0], d3[0]), u8_xor(s[8][1], d3[1]), u8_xor(s[8][2], d3[2]), u8_xor(s[8][3], d3[3]), u8_xor(s[8][4], d3[4]), u8_xor(s[8][5], d3[5]), u8_xor(s[8][6], d3[6]), u8_xor(s[8][7], d3[7])];
+      let t9 = [u8_xor(s[9][0], d4[0]), u8_xor(s[9][1], d4[1]), u8_xor(s[9][2], d4[2]), u8_xor(s[9][3], d4[3]), u8_xor(s[9][4], d4[4]), u8_xor(s[9][5], d4[5]), u8_xor(s[9][6], d4[6]), u8_xor(s[9][7], d4[7])];
+      let t10 = [u8_xor(s[10][0], d0[0]), u8_xor(s[10][1], d0[1]), u8_xor(s[10][2], d0[2]), u8_xor(s[10][3], d0[3]), u8_xor(s[10][4], d0[4]), u8_xor(s[10][5], d0[5]), u8_xor(s[10][6], d0[6]), u8_xor(s[10][7], d0[7])];
+      let t11 = [u8_xor(s[11][0], d1[0]), u8_xor(s[11][1], d1[1]), u8_xor(s[11][2], d1[2]), u8_xor(s[11][3], d1[3]), u8_xor(s[11][4], d1[4]), u8_xor(s[11][5], d1[5]), u8_xor(s[11][6], d1[6]), u8_xor(s[11][7], d1[7])];
+      let t12 = [u8_xor(s[12][0], d2[0]), u8_xor(s[12][1], d2[1]), u8_xor(s[12][2], d2[2]), u8_xor(s[12][3], d2[3]), u8_xor(s[12][4], d2[4]), u8_xor(s[12][5], d2[5]), u8_xor(s[12][6], d2[6]), u8_xor(s[12][7], d2[7])];
+      let t13 = [u8_xor(s[13][0], d3[0]), u8_xor(s[13][1], d3[1]), u8_xor(s[13][2], d3[2]), u8_xor(s[13][3], d3[3]), u8_xor(s[13][4], d3[4]), u8_xor(s[13][5], d3[5]), u8_xor(s[13][6], d3[6]), u8_xor(s[13][7], d3[7])];
+      let t14 = [u8_xor(s[14][0], d4[0]), u8_xor(s[14][1], d4[1]), u8_xor(s[14][2], d4[2]), u8_xor(s[14][3], d4[3]), u8_xor(s[14][4], d4[4]), u8_xor(s[14][5], d4[5]), u8_xor(s[14][6], d4[6]), u8_xor(s[14][7], d4[7])];
+      let t15 = [u8_xor(s[15][0], d0[0]), u8_xor(s[15][1], d0[1]), u8_xor(s[15][2], d0[2]), u8_xor(s[15][3], d0[3]), u8_xor(s[15][4], d0[4]), u8_xor(s[15][5], d0[5]), u8_xor(s[15][6], d0[6]), u8_xor(s[15][7], d0[7])];
+      let t16 = [u8_xor(s[16][0], d1[0]), u8_xor(s[16][1], d1[1]), u8_xor(s[16][2], d1[2]), u8_xor(s[16][3], d1[3]), u8_xor(s[16][4], d1[4]), u8_xor(s[16][5], d1[5]), u8_xor(s[16][6], d1[6]), u8_xor(s[16][7], d1[7])];
+      let t17 = [u8_xor(s[17][0], d2[0]), u8_xor(s[17][1], d2[1]), u8_xor(s[17][2], d2[2]), u8_xor(s[17][3], d2[3]), u8_xor(s[17][4], d2[4]), u8_xor(s[17][5], d2[5]), u8_xor(s[17][6], d2[6]), u8_xor(s[17][7], d2[7])];
+      let t18 = [u8_xor(s[18][0], d3[0]), u8_xor(s[18][1], d3[1]), u8_xor(s[18][2], d3[2]), u8_xor(s[18][3], d3[3]), u8_xor(s[18][4], d3[4]), u8_xor(s[18][5], d3[5]), u8_xor(s[18][6], d3[6]), u8_xor(s[18][7], d3[7])];
+      let t19 = [u8_xor(s[19][0], d4[0]), u8_xor(s[19][1], d4[1]), u8_xor(s[19][2], d4[2]), u8_xor(s[19][3], d4[3]), u8_xor(s[19][4], d4[4]), u8_xor(s[19][5], d4[5]), u8_xor(s[19][6], d4[6]), u8_xor(s[19][7], d4[7])];
+      let t20 = [u8_xor(s[20][0], d0[0]), u8_xor(s[20][1], d0[1]), u8_xor(s[20][2], d0[2]), u8_xor(s[20][3], d0[3]), u8_xor(s[20][4], d0[4]), u8_xor(s[20][5], d0[5]), u8_xor(s[20][6], d0[6]), u8_xor(s[20][7], d0[7])];
+      let t21 = [u8_xor(s[21][0], d1[0]), u8_xor(s[21][1], d1[1]), u8_xor(s[21][2], d1[2]), u8_xor(s[21][3], d1[3]), u8_xor(s[21][4], d1[4]), u8_xor(s[21][5], d1[5]), u8_xor(s[21][6], d1[6]), u8_xor(s[21][7], d1[7])];
+      let t22 = [u8_xor(s[22][0], d2[0]), u8_xor(s[22][1], d2[1]), u8_xor(s[22][2], d2[2]), u8_xor(s[22][3], d2[3]), u8_xor(s[22][4], d2[4]), u8_xor(s[22][5], d2[5]), u8_xor(s[22][6], d2[6]), u8_xor(s[22][7], d2[7])];
+      let t23 = [u8_xor(s[23][0], d3[0]), u8_xor(s[23][1], d3[1]), u8_xor(s[23][2], d3[2]), u8_xor(s[23][3], d3[3]), u8_xor(s[23][4], d3[4]), u8_xor(s[23][5], d3[5]), u8_xor(s[23][6], d3[6]), u8_xor(s[23][7], d3[7])];
+      let t24 = [u8_xor(s[24][0], d4[0]), u8_xor(s[24][1], d4[1]), u8_xor(s[24][2], d4[2]), u8_xor(s[24][3], d4[3]), u8_xor(s[24][4], d4[4]), u8_xor(s[24][5], d4[5]), u8_xor(s[24][6], d4[6]), u8_xor(s[24][7], d4[7])];
+      [t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24]
+  }
+
+  fn keccak_rho_chi_iota(s: [[U8; 8]; 25], rc: [U8; 8]) -> [[U8; 8]; 25] {
+      let t0 = s[0];
+      let t1 = s[1];
+      let t2 = s[2];
+      let t3 = s[3];
+      let t4 = s[4];
+      let t5 = s[5];
+      let t6 = s[6];
+      let t7 = s[7];
+      let t8 = s[8];
+      let t9 = s[9];
+      let t10 = s[10];
+      let t11 = s[11];
+      let t12 = s[12];
+      let t13 = s[13];
+      let t14 = s[14];
+      let t15 = s[15];
+      let t16 = s[16];
+      let t17 = s[17];
+      let t18 = s[18];
+      let t19 = s[19];
+      let t20 = s[20];
+      let t21 = s[21];
+      let t22 = s[22];
+      let t23 = s[23];
+      let t24 = s[24];
+      -- rho + pi: b[pi(src)] = rotl(t[src], rho(src)).
+      -- b0 = rotl(t0, 0): byte rotation only (free)
+      let b0 = [t0[0], t0[1], t0[2], t0[3], t0[4], t0[5], t0[6], t0[7]];
+      -- b10 = rotl(t1, 1) = byte-rotl 0 + bit-shl 1
+      let d10_0 = u8_bit_decomposition(t1[0]);
+      let d10_1 = u8_bit_decomposition(t1[1]);
+      let d10_2 = u8_bit_decomposition(t1[2]);
+      let d10_3 = u8_bit_decomposition(t1[3]);
+      let d10_4 = u8_bit_decomposition(t1[4]);
+      let d10_5 = u8_bit_decomposition(t1[5]);
+      let d10_6 = u8_bit_decomposition(t1[6]);
+      let d10_7 = u8_bit_decomposition(t1[7]);
+      let b10 = [
+        u8_from_field_unsafe(d10_7[7] + 2 * d10_0[0] + 4 * d10_0[1] + 8 * d10_0[2] + 16 * d10_0[3] + 32 * d10_0[4] + 64 * d10_0[5] + 128 * d10_0[6]),
+        u8_from_field_unsafe(d10_0[7] + 2 * d10_1[0] + 4 * d10_1[1] + 8 * d10_1[2] + 16 * d10_1[3] + 32 * d10_1[4] + 64 * d10_1[5] + 128 * d10_1[6]),
+        u8_from_field_unsafe(d10_1[7] + 2 * d10_2[0] + 4 * d10_2[1] + 8 * d10_2[2] + 16 * d10_2[3] + 32 * d10_2[4] + 64 * d10_2[5] + 128 * d10_2[6]),
+        u8_from_field_unsafe(d10_2[7] + 2 * d10_3[0] + 4 * d10_3[1] + 8 * d10_3[2] + 16 * d10_3[3] + 32 * d10_3[4] + 64 * d10_3[5] + 128 * d10_3[6]),
+        u8_from_field_unsafe(d10_3[7] + 2 * d10_4[0] + 4 * d10_4[1] + 8 * d10_4[2] + 16 * d10_4[3] + 32 * d10_4[4] + 64 * d10_4[5] + 128 * d10_4[6]),
+        u8_from_field_unsafe(d10_4[7] + 2 * d10_5[0] + 4 * d10_5[1] + 8 * d10_5[2] + 16 * d10_5[3] + 32 * d10_5[4] + 64 * d10_5[5] + 128 * d10_5[6]),
+        u8_from_field_unsafe(d10_5[7] + 2 * d10_6[0] + 4 * d10_6[1] + 8 * d10_6[2] + 16 * d10_6[3] + 32 * d10_6[4] + 64 * d10_6[5] + 128 * d10_6[6]),
+        u8_from_field_unsafe(d10_6[7] + 2 * d10_7[0] + 4 * d10_7[1] + 8 * d10_7[2] + 16 * d10_7[3] + 32 * d10_7[4] + 64 * d10_7[5] + 128 * d10_7[6])
+      ];
+      -- b20 = rotl(t2, 62) = byte-rotl 7 + bit-shl 6
+      let d20_0 = u8_bit_decomposition(t2[0]);
+      let d20_1 = u8_bit_decomposition(t2[1]);
+      let d20_2 = u8_bit_decomposition(t2[2]);
+      let d20_3 = u8_bit_decomposition(t2[3]);
+      let d20_4 = u8_bit_decomposition(t2[4]);
+      let d20_5 = u8_bit_decomposition(t2[5]);
+      let d20_6 = u8_bit_decomposition(t2[6]);
+      let d20_7 = u8_bit_decomposition(t2[7]);
+      let b20 = [
+        u8_from_field_unsafe(d20_0[2] + 2 * d20_0[3] + 4 * d20_0[4] + 8 * d20_0[5] + 16 * d20_0[6] + 32 * d20_0[7] + 64 * d20_1[0] + 128 * d20_1[1]),
+        u8_from_field_unsafe(d20_1[2] + 2 * d20_1[3] + 4 * d20_1[4] + 8 * d20_1[5] + 16 * d20_1[6] + 32 * d20_1[7] + 64 * d20_2[0] + 128 * d20_2[1]),
+        u8_from_field_unsafe(d20_2[2] + 2 * d20_2[3] + 4 * d20_2[4] + 8 * d20_2[5] + 16 * d20_2[6] + 32 * d20_2[7] + 64 * d20_3[0] + 128 * d20_3[1]),
+        u8_from_field_unsafe(d20_3[2] + 2 * d20_3[3] + 4 * d20_3[4] + 8 * d20_3[5] + 16 * d20_3[6] + 32 * d20_3[7] + 64 * d20_4[0] + 128 * d20_4[1]),
+        u8_from_field_unsafe(d20_4[2] + 2 * d20_4[3] + 4 * d20_4[4] + 8 * d20_4[5] + 16 * d20_4[6] + 32 * d20_4[7] + 64 * d20_5[0] + 128 * d20_5[1]),
+        u8_from_field_unsafe(d20_5[2] + 2 * d20_5[3] + 4 * d20_5[4] + 8 * d20_5[5] + 16 * d20_5[6] + 32 * d20_5[7] + 64 * d20_6[0] + 128 * d20_6[1]),
+        u8_from_field_unsafe(d20_6[2] + 2 * d20_6[3] + 4 * d20_6[4] + 8 * d20_6[5] + 16 * d20_6[6] + 32 * d20_6[7] + 64 * d20_7[0] + 128 * d20_7[1]),
+        u8_from_field_unsafe(d20_7[2] + 2 * d20_7[3] + 4 * d20_7[4] + 8 * d20_7[5] + 16 * d20_7[6] + 32 * d20_7[7] + 64 * d20_0[0] + 128 * d20_0[1])
+      ];
+      -- b5 = rotl(t3, 28) = byte-rotl 3 + bit-shl 4
+      let d5_0 = u8_bit_decomposition(t3[0]);
+      let d5_1 = u8_bit_decomposition(t3[1]);
+      let d5_2 = u8_bit_decomposition(t3[2]);
+      let d5_3 = u8_bit_decomposition(t3[3]);
+      let d5_4 = u8_bit_decomposition(t3[4]);
+      let d5_5 = u8_bit_decomposition(t3[5]);
+      let d5_6 = u8_bit_decomposition(t3[6]);
+      let d5_7 = u8_bit_decomposition(t3[7]);
+      let b5 = [
+        u8_from_field_unsafe(d5_4[4] + 2 * d5_4[5] + 4 * d5_4[6] + 8 * d5_4[7] + 16 * d5_5[0] + 32 * d5_5[1] + 64 * d5_5[2] + 128 * d5_5[3]),
+        u8_from_field_unsafe(d5_5[4] + 2 * d5_5[5] + 4 * d5_5[6] + 8 * d5_5[7] + 16 * d5_6[0] + 32 * d5_6[1] + 64 * d5_6[2] + 128 * d5_6[3]),
+        u8_from_field_unsafe(d5_6[4] + 2 * d5_6[5] + 4 * d5_6[6] + 8 * d5_6[7] + 16 * d5_7[0] + 32 * d5_7[1] + 64 * d5_7[2] + 128 * d5_7[3]),
+        u8_from_field_unsafe(d5_7[4] + 2 * d5_7[5] + 4 * d5_7[6] + 8 * d5_7[7] + 16 * d5_0[0] + 32 * d5_0[1] + 64 * d5_0[2] + 128 * d5_0[3]),
+        u8_from_field_unsafe(d5_0[4] + 2 * d5_0[5] + 4 * d5_0[6] + 8 * d5_0[7] + 16 * d5_1[0] + 32 * d5_1[1] + 64 * d5_1[2] + 128 * d5_1[3]),
+        u8_from_field_unsafe(d5_1[4] + 2 * d5_1[5] + 4 * d5_1[6] + 8 * d5_1[7] + 16 * d5_2[0] + 32 * d5_2[1] + 64 * d5_2[2] + 128 * d5_2[3]),
+        u8_from_field_unsafe(d5_2[4] + 2 * d5_2[5] + 4 * d5_2[6] + 8 * d5_2[7] + 16 * d5_3[0] + 32 * d5_3[1] + 64 * d5_3[2] + 128 * d5_3[3]),
+        u8_from_field_unsafe(d5_3[4] + 2 * d5_3[5] + 4 * d5_3[6] + 8 * d5_3[7] + 16 * d5_4[0] + 32 * d5_4[1] + 64 * d5_4[2] + 128 * d5_4[3])
+      ];
+      -- b15 = rotl(t4, 27) = byte-rotl 3 + bit-shl 3
+      let d15_0 = u8_bit_decomposition(t4[0]);
+      let d15_1 = u8_bit_decomposition(t4[1]);
+      let d15_2 = u8_bit_decomposition(t4[2]);
+      let d15_3 = u8_bit_decomposition(t4[3]);
+      let d15_4 = u8_bit_decomposition(t4[4]);
+      let d15_5 = u8_bit_decomposition(t4[5]);
+      let d15_6 = u8_bit_decomposition(t4[6]);
+      let d15_7 = u8_bit_decomposition(t4[7]);
+      let b15 = [
+        u8_from_field_unsafe(d15_4[5] + 2 * d15_4[6] + 4 * d15_4[7] + 8 * d15_5[0] + 16 * d15_5[1] + 32 * d15_5[2] + 64 * d15_5[3] + 128 * d15_5[4]),
+        u8_from_field_unsafe(d15_5[5] + 2 * d15_5[6] + 4 * d15_5[7] + 8 * d15_6[0] + 16 * d15_6[1] + 32 * d15_6[2] + 64 * d15_6[3] + 128 * d15_6[4]),
+        u8_from_field_unsafe(d15_6[5] + 2 * d15_6[6] + 4 * d15_6[7] + 8 * d15_7[0] + 16 * d15_7[1] + 32 * d15_7[2] + 64 * d15_7[3] + 128 * d15_7[4]),
+        u8_from_field_unsafe(d15_7[5] + 2 * d15_7[6] + 4 * d15_7[7] + 8 * d15_0[0] + 16 * d15_0[1] + 32 * d15_0[2] + 64 * d15_0[3] + 128 * d15_0[4]),
+        u8_from_field_unsafe(d15_0[5] + 2 * d15_0[6] + 4 * d15_0[7] + 8 * d15_1[0] + 16 * d15_1[1] + 32 * d15_1[2] + 64 * d15_1[3] + 128 * d15_1[4]),
+        u8_from_field_unsafe(d15_1[5] + 2 * d15_1[6] + 4 * d15_1[7] + 8 * d15_2[0] + 16 * d15_2[1] + 32 * d15_2[2] + 64 * d15_2[3] + 128 * d15_2[4]),
+        u8_from_field_unsafe(d15_2[5] + 2 * d15_2[6] + 4 * d15_2[7] + 8 * d15_3[0] + 16 * d15_3[1] + 32 * d15_3[2] + 64 * d15_3[3] + 128 * d15_3[4]),
+        u8_from_field_unsafe(d15_3[5] + 2 * d15_3[6] + 4 * d15_3[7] + 8 * d15_4[0] + 16 * d15_4[1] + 32 * d15_4[2] + 64 * d15_4[3] + 128 * d15_4[4])
+      ];
+      -- b16 = rotl(t5, 36) = byte-rotl 4 + bit-shl 4
+      let d16_0 = u8_bit_decomposition(t5[0]);
+      let d16_1 = u8_bit_decomposition(t5[1]);
+      let d16_2 = u8_bit_decomposition(t5[2]);
+      let d16_3 = u8_bit_decomposition(t5[3]);
+      let d16_4 = u8_bit_decomposition(t5[4]);
+      let d16_5 = u8_bit_decomposition(t5[5]);
+      let d16_6 = u8_bit_decomposition(t5[6]);
+      let d16_7 = u8_bit_decomposition(t5[7]);
+      let b16 = [
+        u8_from_field_unsafe(d16_3[4] + 2 * d16_3[5] + 4 * d16_3[6] + 8 * d16_3[7] + 16 * d16_4[0] + 32 * d16_4[1] + 64 * d16_4[2] + 128 * d16_4[3]),
+        u8_from_field_unsafe(d16_4[4] + 2 * d16_4[5] + 4 * d16_4[6] + 8 * d16_4[7] + 16 * d16_5[0] + 32 * d16_5[1] + 64 * d16_5[2] + 128 * d16_5[3]),
+        u8_from_field_unsafe(d16_5[4] + 2 * d16_5[5] + 4 * d16_5[6] + 8 * d16_5[7] + 16 * d16_6[0] + 32 * d16_6[1] + 64 * d16_6[2] + 128 * d16_6[3]),
+        u8_from_field_unsafe(d16_6[4] + 2 * d16_6[5] + 4 * d16_6[6] + 8 * d16_6[7] + 16 * d16_7[0] + 32 * d16_7[1] + 64 * d16_7[2] + 128 * d16_7[3]),
+        u8_from_field_unsafe(d16_7[4] + 2 * d16_7[5] + 4 * d16_7[6] + 8 * d16_7[7] + 16 * d16_0[0] + 32 * d16_0[1] + 64 * d16_0[2] + 128 * d16_0[3]),
+        u8_from_field_unsafe(d16_0[4] + 2 * d16_0[5] + 4 * d16_0[6] + 8 * d16_0[7] + 16 * d16_1[0] + 32 * d16_1[1] + 64 * d16_1[2] + 128 * d16_1[3]),
+        u8_from_field_unsafe(d16_1[4] + 2 * d16_1[5] + 4 * d16_1[6] + 8 * d16_1[7] + 16 * d16_2[0] + 32 * d16_2[1] + 64 * d16_2[2] + 128 * d16_2[3]),
+        u8_from_field_unsafe(d16_2[4] + 2 * d16_2[5] + 4 * d16_2[6] + 8 * d16_2[7] + 16 * d16_3[0] + 32 * d16_3[1] + 64 * d16_3[2] + 128 * d16_3[3])
+      ];
+      -- b1 = rotl(t6, 44) = byte-rotl 5 + bit-shl 4
+      let d1_0 = u8_bit_decomposition(t6[0]);
+      let d1_1 = u8_bit_decomposition(t6[1]);
+      let d1_2 = u8_bit_decomposition(t6[2]);
+      let d1_3 = u8_bit_decomposition(t6[3]);
+      let d1_4 = u8_bit_decomposition(t6[4]);
+      let d1_5 = u8_bit_decomposition(t6[5]);
+      let d1_6 = u8_bit_decomposition(t6[6]);
+      let d1_7 = u8_bit_decomposition(t6[7]);
+      let b1 = [
+        u8_from_field_unsafe(d1_2[4] + 2 * d1_2[5] + 4 * d1_2[6] + 8 * d1_2[7] + 16 * d1_3[0] + 32 * d1_3[1] + 64 * d1_3[2] + 128 * d1_3[3]),
+        u8_from_field_unsafe(d1_3[4] + 2 * d1_3[5] + 4 * d1_3[6] + 8 * d1_3[7] + 16 * d1_4[0] + 32 * d1_4[1] + 64 * d1_4[2] + 128 * d1_4[3]),
+        u8_from_field_unsafe(d1_4[4] + 2 * d1_4[5] + 4 * d1_4[6] + 8 * d1_4[7] + 16 * d1_5[0] + 32 * d1_5[1] + 64 * d1_5[2] + 128 * d1_5[3]),
+        u8_from_field_unsafe(d1_5[4] + 2 * d1_5[5] + 4 * d1_5[6] + 8 * d1_5[7] + 16 * d1_6[0] + 32 * d1_6[1] + 64 * d1_6[2] + 128 * d1_6[3]),
+        u8_from_field_unsafe(d1_6[4] + 2 * d1_6[5] + 4 * d1_6[6] + 8 * d1_6[7] + 16 * d1_7[0] + 32 * d1_7[1] + 64 * d1_7[2] + 128 * d1_7[3]),
+        u8_from_field_unsafe(d1_7[4] + 2 * d1_7[5] + 4 * d1_7[6] + 8 * d1_7[7] + 16 * d1_0[0] + 32 * d1_0[1] + 64 * d1_0[2] + 128 * d1_0[3]),
+        u8_from_field_unsafe(d1_0[4] + 2 * d1_0[5] + 4 * d1_0[6] + 8 * d1_0[7] + 16 * d1_1[0] + 32 * d1_1[1] + 64 * d1_1[2] + 128 * d1_1[3]),
+        u8_from_field_unsafe(d1_1[4] + 2 * d1_1[5] + 4 * d1_1[6] + 8 * d1_1[7] + 16 * d1_2[0] + 32 * d1_2[1] + 64 * d1_2[2] + 128 * d1_2[3])
+      ];
+      -- b11 = rotl(t7, 6) = byte-rotl 0 + bit-shl 6
+      let d11_0 = u8_bit_decomposition(t7[0]);
+      let d11_1 = u8_bit_decomposition(t7[1]);
+      let d11_2 = u8_bit_decomposition(t7[2]);
+      let d11_3 = u8_bit_decomposition(t7[3]);
+      let d11_4 = u8_bit_decomposition(t7[4]);
+      let d11_5 = u8_bit_decomposition(t7[5]);
+      let d11_6 = u8_bit_decomposition(t7[6]);
+      let d11_7 = u8_bit_decomposition(t7[7]);
+      let b11 = [
+        u8_from_field_unsafe(d11_7[2] + 2 * d11_7[3] + 4 * d11_7[4] + 8 * d11_7[5] + 16 * d11_7[6] + 32 * d11_7[7] + 64 * d11_0[0] + 128 * d11_0[1]),
+        u8_from_field_unsafe(d11_0[2] + 2 * d11_0[3] + 4 * d11_0[4] + 8 * d11_0[5] + 16 * d11_0[6] + 32 * d11_0[7] + 64 * d11_1[0] + 128 * d11_1[1]),
+        u8_from_field_unsafe(d11_1[2] + 2 * d11_1[3] + 4 * d11_1[4] + 8 * d11_1[5] + 16 * d11_1[6] + 32 * d11_1[7] + 64 * d11_2[0] + 128 * d11_2[1]),
+        u8_from_field_unsafe(d11_2[2] + 2 * d11_2[3] + 4 * d11_2[4] + 8 * d11_2[5] + 16 * d11_2[6] + 32 * d11_2[7] + 64 * d11_3[0] + 128 * d11_3[1]),
+        u8_from_field_unsafe(d11_3[2] + 2 * d11_3[3] + 4 * d11_3[4] + 8 * d11_3[5] + 16 * d11_3[6] + 32 * d11_3[7] + 64 * d11_4[0] + 128 * d11_4[1]),
+        u8_from_field_unsafe(d11_4[2] + 2 * d11_4[3] + 4 * d11_4[4] + 8 * d11_4[5] + 16 * d11_4[6] + 32 * d11_4[7] + 64 * d11_5[0] + 128 * d11_5[1]),
+        u8_from_field_unsafe(d11_5[2] + 2 * d11_5[3] + 4 * d11_5[4] + 8 * d11_5[5] + 16 * d11_5[6] + 32 * d11_5[7] + 64 * d11_6[0] + 128 * d11_6[1]),
+        u8_from_field_unsafe(d11_6[2] + 2 * d11_6[3] + 4 * d11_6[4] + 8 * d11_6[5] + 16 * d11_6[6] + 32 * d11_6[7] + 64 * d11_7[0] + 128 * d11_7[1])
+      ];
+      -- b21 = rotl(t8, 55) = byte-rotl 6 + bit-shl 7
+      let d21_0 = u8_bit_decomposition(t8[0]);
+      let d21_1 = u8_bit_decomposition(t8[1]);
+      let d21_2 = u8_bit_decomposition(t8[2]);
+      let d21_3 = u8_bit_decomposition(t8[3]);
+      let d21_4 = u8_bit_decomposition(t8[4]);
+      let d21_5 = u8_bit_decomposition(t8[5]);
+      let d21_6 = u8_bit_decomposition(t8[6]);
+      let d21_7 = u8_bit_decomposition(t8[7]);
+      let b21 = [
+        u8_from_field_unsafe(d21_1[1] + 2 * d21_1[2] + 4 * d21_1[3] + 8 * d21_1[4] + 16 * d21_1[5] + 32 * d21_1[6] + 64 * d21_1[7] + 128 * d21_2[0]),
+        u8_from_field_unsafe(d21_2[1] + 2 * d21_2[2] + 4 * d21_2[3] + 8 * d21_2[4] + 16 * d21_2[5] + 32 * d21_2[6] + 64 * d21_2[7] + 128 * d21_3[0]),
+        u8_from_field_unsafe(d21_3[1] + 2 * d21_3[2] + 4 * d21_3[3] + 8 * d21_3[4] + 16 * d21_3[5] + 32 * d21_3[6] + 64 * d21_3[7] + 128 * d21_4[0]),
+        u8_from_field_unsafe(d21_4[1] + 2 * d21_4[2] + 4 * d21_4[3] + 8 * d21_4[4] + 16 * d21_4[5] + 32 * d21_4[6] + 64 * d21_4[7] + 128 * d21_5[0]),
+        u8_from_field_unsafe(d21_5[1] + 2 * d21_5[2] + 4 * d21_5[3] + 8 * d21_5[4] + 16 * d21_5[5] + 32 * d21_5[6] + 64 * d21_5[7] + 128 * d21_6[0]),
+        u8_from_field_unsafe(d21_6[1] + 2 * d21_6[2] + 4 * d21_6[3] + 8 * d21_6[4] + 16 * d21_6[5] + 32 * d21_6[6] + 64 * d21_6[7] + 128 * d21_7[0]),
+        u8_from_field_unsafe(d21_7[1] + 2 * d21_7[2] + 4 * d21_7[3] + 8 * d21_7[4] + 16 * d21_7[5] + 32 * d21_7[6] + 64 * d21_7[7] + 128 * d21_0[0]),
+        u8_from_field_unsafe(d21_0[1] + 2 * d21_0[2] + 4 * d21_0[3] + 8 * d21_0[4] + 16 * d21_0[5] + 32 * d21_0[6] + 64 * d21_0[7] + 128 * d21_1[0])
+      ];
+      -- b6 = rotl(t9, 20) = byte-rotl 2 + bit-shl 4
+      let d6_0 = u8_bit_decomposition(t9[0]);
+      let d6_1 = u8_bit_decomposition(t9[1]);
+      let d6_2 = u8_bit_decomposition(t9[2]);
+      let d6_3 = u8_bit_decomposition(t9[3]);
+      let d6_4 = u8_bit_decomposition(t9[4]);
+      let d6_5 = u8_bit_decomposition(t9[5]);
+      let d6_6 = u8_bit_decomposition(t9[6]);
+      let d6_7 = u8_bit_decomposition(t9[7]);
+      let b6 = [
+        u8_from_field_unsafe(d6_5[4] + 2 * d6_5[5] + 4 * d6_5[6] + 8 * d6_5[7] + 16 * d6_6[0] + 32 * d6_6[1] + 64 * d6_6[2] + 128 * d6_6[3]),
+        u8_from_field_unsafe(d6_6[4] + 2 * d6_6[5] + 4 * d6_6[6] + 8 * d6_6[7] + 16 * d6_7[0] + 32 * d6_7[1] + 64 * d6_7[2] + 128 * d6_7[3]),
+        u8_from_field_unsafe(d6_7[4] + 2 * d6_7[5] + 4 * d6_7[6] + 8 * d6_7[7] + 16 * d6_0[0] + 32 * d6_0[1] + 64 * d6_0[2] + 128 * d6_0[3]),
+        u8_from_field_unsafe(d6_0[4] + 2 * d6_0[5] + 4 * d6_0[6] + 8 * d6_0[7] + 16 * d6_1[0] + 32 * d6_1[1] + 64 * d6_1[2] + 128 * d6_1[3]),
+        u8_from_field_unsafe(d6_1[4] + 2 * d6_1[5] + 4 * d6_1[6] + 8 * d6_1[7] + 16 * d6_2[0] + 32 * d6_2[1] + 64 * d6_2[2] + 128 * d6_2[3]),
+        u8_from_field_unsafe(d6_2[4] + 2 * d6_2[5] + 4 * d6_2[6] + 8 * d6_2[7] + 16 * d6_3[0] + 32 * d6_3[1] + 64 * d6_3[2] + 128 * d6_3[3]),
+        u8_from_field_unsafe(d6_3[4] + 2 * d6_3[5] + 4 * d6_3[6] + 8 * d6_3[7] + 16 * d6_4[0] + 32 * d6_4[1] + 64 * d6_4[2] + 128 * d6_4[3]),
+        u8_from_field_unsafe(d6_4[4] + 2 * d6_4[5] + 4 * d6_4[6] + 8 * d6_4[7] + 16 * d6_5[0] + 32 * d6_5[1] + 64 * d6_5[2] + 128 * d6_5[3])
+      ];
+      -- b7 = rotl(t10, 3) = byte-rotl 0 + bit-shl 3
+      let d7_0 = u8_bit_decomposition(t10[0]);
+      let d7_1 = u8_bit_decomposition(t10[1]);
+      let d7_2 = u8_bit_decomposition(t10[2]);
+      let d7_3 = u8_bit_decomposition(t10[3]);
+      let d7_4 = u8_bit_decomposition(t10[4]);
+      let d7_5 = u8_bit_decomposition(t10[5]);
+      let d7_6 = u8_bit_decomposition(t10[6]);
+      let d7_7 = u8_bit_decomposition(t10[7]);
+      let b7 = [
+        u8_from_field_unsafe(d7_7[5] + 2 * d7_7[6] + 4 * d7_7[7] + 8 * d7_0[0] + 16 * d7_0[1] + 32 * d7_0[2] + 64 * d7_0[3] + 128 * d7_0[4]),
+        u8_from_field_unsafe(d7_0[5] + 2 * d7_0[6] + 4 * d7_0[7] + 8 * d7_1[0] + 16 * d7_1[1] + 32 * d7_1[2] + 64 * d7_1[3] + 128 * d7_1[4]),
+        u8_from_field_unsafe(d7_1[5] + 2 * d7_1[6] + 4 * d7_1[7] + 8 * d7_2[0] + 16 * d7_2[1] + 32 * d7_2[2] + 64 * d7_2[3] + 128 * d7_2[4]),
+        u8_from_field_unsafe(d7_2[5] + 2 * d7_2[6] + 4 * d7_2[7] + 8 * d7_3[0] + 16 * d7_3[1] + 32 * d7_3[2] + 64 * d7_3[3] + 128 * d7_3[4]),
+        u8_from_field_unsafe(d7_3[5] + 2 * d7_3[6] + 4 * d7_3[7] + 8 * d7_4[0] + 16 * d7_4[1] + 32 * d7_4[2] + 64 * d7_4[3] + 128 * d7_4[4]),
+        u8_from_field_unsafe(d7_4[5] + 2 * d7_4[6] + 4 * d7_4[7] + 8 * d7_5[0] + 16 * d7_5[1] + 32 * d7_5[2] + 64 * d7_5[3] + 128 * d7_5[4]),
+        u8_from_field_unsafe(d7_5[5] + 2 * d7_5[6] + 4 * d7_5[7] + 8 * d7_6[0] + 16 * d7_6[1] + 32 * d7_6[2] + 64 * d7_6[3] + 128 * d7_6[4]),
+        u8_from_field_unsafe(d7_6[5] + 2 * d7_6[6] + 4 * d7_6[7] + 8 * d7_7[0] + 16 * d7_7[1] + 32 * d7_7[2] + 64 * d7_7[3] + 128 * d7_7[4])
+      ];
+      -- b17 = rotl(t11, 10) = byte-rotl 1 + bit-shl 2
+      let d17_0 = u8_bit_decomposition(t11[0]);
+      let d17_1 = u8_bit_decomposition(t11[1]);
+      let d17_2 = u8_bit_decomposition(t11[2]);
+      let d17_3 = u8_bit_decomposition(t11[3]);
+      let d17_4 = u8_bit_decomposition(t11[4]);
+      let d17_5 = u8_bit_decomposition(t11[5]);
+      let d17_6 = u8_bit_decomposition(t11[6]);
+      let d17_7 = u8_bit_decomposition(t11[7]);
+      let b17 = [
+        u8_from_field_unsafe(d17_6[6] + 2 * d17_6[7] + 4 * d17_7[0] + 8 * d17_7[1] + 16 * d17_7[2] + 32 * d17_7[3] + 64 * d17_7[4] + 128 * d17_7[5]),
+        u8_from_field_unsafe(d17_7[6] + 2 * d17_7[7] + 4 * d17_0[0] + 8 * d17_0[1] + 16 * d17_0[2] + 32 * d17_0[3] + 64 * d17_0[4] + 128 * d17_0[5]),
+        u8_from_field_unsafe(d17_0[6] + 2 * d17_0[7] + 4 * d17_1[0] + 8 * d17_1[1] + 16 * d17_1[2] + 32 * d17_1[3] + 64 * d17_1[4] + 128 * d17_1[5]),
+        u8_from_field_unsafe(d17_1[6] + 2 * d17_1[7] + 4 * d17_2[0] + 8 * d17_2[1] + 16 * d17_2[2] + 32 * d17_2[3] + 64 * d17_2[4] + 128 * d17_2[5]),
+        u8_from_field_unsafe(d17_2[6] + 2 * d17_2[7] + 4 * d17_3[0] + 8 * d17_3[1] + 16 * d17_3[2] + 32 * d17_3[3] + 64 * d17_3[4] + 128 * d17_3[5]),
+        u8_from_field_unsafe(d17_3[6] + 2 * d17_3[7] + 4 * d17_4[0] + 8 * d17_4[1] + 16 * d17_4[2] + 32 * d17_4[3] + 64 * d17_4[4] + 128 * d17_4[5]),
+        u8_from_field_unsafe(d17_4[6] + 2 * d17_4[7] + 4 * d17_5[0] + 8 * d17_5[1] + 16 * d17_5[2] + 32 * d17_5[3] + 64 * d17_5[4] + 128 * d17_5[5]),
+        u8_from_field_unsafe(d17_5[6] + 2 * d17_5[7] + 4 * d17_6[0] + 8 * d17_6[1] + 16 * d17_6[2] + 32 * d17_6[3] + 64 * d17_6[4] + 128 * d17_6[5])
+      ];
+      -- b2 = rotl(t12, 43) = byte-rotl 5 + bit-shl 3
+      let d2_0 = u8_bit_decomposition(t12[0]);
+      let d2_1 = u8_bit_decomposition(t12[1]);
+      let d2_2 = u8_bit_decomposition(t12[2]);
+      let d2_3 = u8_bit_decomposition(t12[3]);
+      let d2_4 = u8_bit_decomposition(t12[4]);
+      let d2_5 = u8_bit_decomposition(t12[5]);
+      let d2_6 = u8_bit_decomposition(t12[6]);
+      let d2_7 = u8_bit_decomposition(t12[7]);
+      let b2 = [
+        u8_from_field_unsafe(d2_2[5] + 2 * d2_2[6] + 4 * d2_2[7] + 8 * d2_3[0] + 16 * d2_3[1] + 32 * d2_3[2] + 64 * d2_3[3] + 128 * d2_3[4]),
+        u8_from_field_unsafe(d2_3[5] + 2 * d2_3[6] + 4 * d2_3[7] + 8 * d2_4[0] + 16 * d2_4[1] + 32 * d2_4[2] + 64 * d2_4[3] + 128 * d2_4[4]),
+        u8_from_field_unsafe(d2_4[5] + 2 * d2_4[6] + 4 * d2_4[7] + 8 * d2_5[0] + 16 * d2_5[1] + 32 * d2_5[2] + 64 * d2_5[3] + 128 * d2_5[4]),
+        u8_from_field_unsafe(d2_5[5] + 2 * d2_5[6] + 4 * d2_5[7] + 8 * d2_6[0] + 16 * d2_6[1] + 32 * d2_6[2] + 64 * d2_6[3] + 128 * d2_6[4]),
+        u8_from_field_unsafe(d2_6[5] + 2 * d2_6[6] + 4 * d2_6[7] + 8 * d2_7[0] + 16 * d2_7[1] + 32 * d2_7[2] + 64 * d2_7[3] + 128 * d2_7[4]),
+        u8_from_field_unsafe(d2_7[5] + 2 * d2_7[6] + 4 * d2_7[7] + 8 * d2_0[0] + 16 * d2_0[1] + 32 * d2_0[2] + 64 * d2_0[3] + 128 * d2_0[4]),
+        u8_from_field_unsafe(d2_0[5] + 2 * d2_0[6] + 4 * d2_0[7] + 8 * d2_1[0] + 16 * d2_1[1] + 32 * d2_1[2] + 64 * d2_1[3] + 128 * d2_1[4]),
+        u8_from_field_unsafe(d2_1[5] + 2 * d2_1[6] + 4 * d2_1[7] + 8 * d2_2[0] + 16 * d2_2[1] + 32 * d2_2[2] + 64 * d2_2[3] + 128 * d2_2[4])
+      ];
+      -- b12 = rotl(t13, 25) = byte-rotl 3 + bit-shl 1
+      let d12_0 = u8_bit_decomposition(t13[0]);
+      let d12_1 = u8_bit_decomposition(t13[1]);
+      let d12_2 = u8_bit_decomposition(t13[2]);
+      let d12_3 = u8_bit_decomposition(t13[3]);
+      let d12_4 = u8_bit_decomposition(t13[4]);
+      let d12_5 = u8_bit_decomposition(t13[5]);
+      let d12_6 = u8_bit_decomposition(t13[6]);
+      let d12_7 = u8_bit_decomposition(t13[7]);
+      let b12 = [
+        u8_from_field_unsafe(d12_4[7] + 2 * d12_5[0] + 4 * d12_5[1] + 8 * d12_5[2] + 16 * d12_5[3] + 32 * d12_5[4] + 64 * d12_5[5] + 128 * d12_5[6]),
+        u8_from_field_unsafe(d12_5[7] + 2 * d12_6[0] + 4 * d12_6[1] + 8 * d12_6[2] + 16 * d12_6[3] + 32 * d12_6[4] + 64 * d12_6[5] + 128 * d12_6[6]),
+        u8_from_field_unsafe(d12_6[7] + 2 * d12_7[0] + 4 * d12_7[1] + 8 * d12_7[2] + 16 * d12_7[3] + 32 * d12_7[4] + 64 * d12_7[5] + 128 * d12_7[6]),
+        u8_from_field_unsafe(d12_7[7] + 2 * d12_0[0] + 4 * d12_0[1] + 8 * d12_0[2] + 16 * d12_0[3] + 32 * d12_0[4] + 64 * d12_0[5] + 128 * d12_0[6]),
+        u8_from_field_unsafe(d12_0[7] + 2 * d12_1[0] + 4 * d12_1[1] + 8 * d12_1[2] + 16 * d12_1[3] + 32 * d12_1[4] + 64 * d12_1[5] + 128 * d12_1[6]),
+        u8_from_field_unsafe(d12_1[7] + 2 * d12_2[0] + 4 * d12_2[1] + 8 * d12_2[2] + 16 * d12_2[3] + 32 * d12_2[4] + 64 * d12_2[5] + 128 * d12_2[6]),
+        u8_from_field_unsafe(d12_2[7] + 2 * d12_3[0] + 4 * d12_3[1] + 8 * d12_3[2] + 16 * d12_3[3] + 32 * d12_3[4] + 64 * d12_3[5] + 128 * d12_3[6]),
+        u8_from_field_unsafe(d12_3[7] + 2 * d12_4[0] + 4 * d12_4[1] + 8 * d12_4[2] + 16 * d12_4[3] + 32 * d12_4[4] + 64 * d12_4[5] + 128 * d12_4[6])
+      ];
+      -- b22 = rotl(t14, 39) = byte-rotl 4 + bit-shl 7
+      let d22_0 = u8_bit_decomposition(t14[0]);
+      let d22_1 = u8_bit_decomposition(t14[1]);
+      let d22_2 = u8_bit_decomposition(t14[2]);
+      let d22_3 = u8_bit_decomposition(t14[3]);
+      let d22_4 = u8_bit_decomposition(t14[4]);
+      let d22_5 = u8_bit_decomposition(t14[5]);
+      let d22_6 = u8_bit_decomposition(t14[6]);
+      let d22_7 = u8_bit_decomposition(t14[7]);
+      let b22 = [
+        u8_from_field_unsafe(d22_3[1] + 2 * d22_3[2] + 4 * d22_3[3] + 8 * d22_3[4] + 16 * d22_3[5] + 32 * d22_3[6] + 64 * d22_3[7] + 128 * d22_4[0]),
+        u8_from_field_unsafe(d22_4[1] + 2 * d22_4[2] + 4 * d22_4[3] + 8 * d22_4[4] + 16 * d22_4[5] + 32 * d22_4[6] + 64 * d22_4[7] + 128 * d22_5[0]),
+        u8_from_field_unsafe(d22_5[1] + 2 * d22_5[2] + 4 * d22_5[3] + 8 * d22_5[4] + 16 * d22_5[5] + 32 * d22_5[6] + 64 * d22_5[7] + 128 * d22_6[0]),
+        u8_from_field_unsafe(d22_6[1] + 2 * d22_6[2] + 4 * d22_6[3] + 8 * d22_6[4] + 16 * d22_6[5] + 32 * d22_6[6] + 64 * d22_6[7] + 128 * d22_7[0]),
+        u8_from_field_unsafe(d22_7[1] + 2 * d22_7[2] + 4 * d22_7[3] + 8 * d22_7[4] + 16 * d22_7[5] + 32 * d22_7[6] + 64 * d22_7[7] + 128 * d22_0[0]),
+        u8_from_field_unsafe(d22_0[1] + 2 * d22_0[2] + 4 * d22_0[3] + 8 * d22_0[4] + 16 * d22_0[5] + 32 * d22_0[6] + 64 * d22_0[7] + 128 * d22_1[0]),
+        u8_from_field_unsafe(d22_1[1] + 2 * d22_1[2] + 4 * d22_1[3] + 8 * d22_1[4] + 16 * d22_1[5] + 32 * d22_1[6] + 64 * d22_1[7] + 128 * d22_2[0]),
+        u8_from_field_unsafe(d22_2[1] + 2 * d22_2[2] + 4 * d22_2[3] + 8 * d22_2[4] + 16 * d22_2[5] + 32 * d22_2[6] + 64 * d22_2[7] + 128 * d22_3[0])
+      ];
+      -- b23 = rotl(t15, 41) = byte-rotl 5 + bit-shl 1
+      let d23_0 = u8_bit_decomposition(t15[0]);
+      let d23_1 = u8_bit_decomposition(t15[1]);
+      let d23_2 = u8_bit_decomposition(t15[2]);
+      let d23_3 = u8_bit_decomposition(t15[3]);
+      let d23_4 = u8_bit_decomposition(t15[4]);
+      let d23_5 = u8_bit_decomposition(t15[5]);
+      let d23_6 = u8_bit_decomposition(t15[6]);
+      let d23_7 = u8_bit_decomposition(t15[7]);
+      let b23 = [
+        u8_from_field_unsafe(d23_2[7] + 2 * d23_3[0] + 4 * d23_3[1] + 8 * d23_3[2] + 16 * d23_3[3] + 32 * d23_3[4] + 64 * d23_3[5] + 128 * d23_3[6]),
+        u8_from_field_unsafe(d23_3[7] + 2 * d23_4[0] + 4 * d23_4[1] + 8 * d23_4[2] + 16 * d23_4[3] + 32 * d23_4[4] + 64 * d23_4[5] + 128 * d23_4[6]),
+        u8_from_field_unsafe(d23_4[7] + 2 * d23_5[0] + 4 * d23_5[1] + 8 * d23_5[2] + 16 * d23_5[3] + 32 * d23_5[4] + 64 * d23_5[5] + 128 * d23_5[6]),
+        u8_from_field_unsafe(d23_5[7] + 2 * d23_6[0] + 4 * d23_6[1] + 8 * d23_6[2] + 16 * d23_6[3] + 32 * d23_6[4] + 64 * d23_6[5] + 128 * d23_6[6]),
+        u8_from_field_unsafe(d23_6[7] + 2 * d23_7[0] + 4 * d23_7[1] + 8 * d23_7[2] + 16 * d23_7[3] + 32 * d23_7[4] + 64 * d23_7[5] + 128 * d23_7[6]),
+        u8_from_field_unsafe(d23_7[7] + 2 * d23_0[0] + 4 * d23_0[1] + 8 * d23_0[2] + 16 * d23_0[3] + 32 * d23_0[4] + 64 * d23_0[5] + 128 * d23_0[6]),
+        u8_from_field_unsafe(d23_0[7] + 2 * d23_1[0] + 4 * d23_1[1] + 8 * d23_1[2] + 16 * d23_1[3] + 32 * d23_1[4] + 64 * d23_1[5] + 128 * d23_1[6]),
+        u8_from_field_unsafe(d23_1[7] + 2 * d23_2[0] + 4 * d23_2[1] + 8 * d23_2[2] + 16 * d23_2[3] + 32 * d23_2[4] + 64 * d23_2[5] + 128 * d23_2[6])
+      ];
+      -- b8 = rotl(t16, 45) = byte-rotl 5 + bit-shl 5
+      let d8_0 = u8_bit_decomposition(t16[0]);
+      let d8_1 = u8_bit_decomposition(t16[1]);
+      let d8_2 = u8_bit_decomposition(t16[2]);
+      let d8_3 = u8_bit_decomposition(t16[3]);
+      let d8_4 = u8_bit_decomposition(t16[4]);
+      let d8_5 = u8_bit_decomposition(t16[5]);
+      let d8_6 = u8_bit_decomposition(t16[6]);
+      let d8_7 = u8_bit_decomposition(t16[7]);
+      let b8 = [
+        u8_from_field_unsafe(d8_2[3] + 2 * d8_2[4] + 4 * d8_2[5] + 8 * d8_2[6] + 16 * d8_2[7] + 32 * d8_3[0] + 64 * d8_3[1] + 128 * d8_3[2]),
+        u8_from_field_unsafe(d8_3[3] + 2 * d8_3[4] + 4 * d8_3[5] + 8 * d8_3[6] + 16 * d8_3[7] + 32 * d8_4[0] + 64 * d8_4[1] + 128 * d8_4[2]),
+        u8_from_field_unsafe(d8_4[3] + 2 * d8_4[4] + 4 * d8_4[5] + 8 * d8_4[6] + 16 * d8_4[7] + 32 * d8_5[0] + 64 * d8_5[1] + 128 * d8_5[2]),
+        u8_from_field_unsafe(d8_5[3] + 2 * d8_5[4] + 4 * d8_5[5] + 8 * d8_5[6] + 16 * d8_5[7] + 32 * d8_6[0] + 64 * d8_6[1] + 128 * d8_6[2]),
+        u8_from_field_unsafe(d8_6[3] + 2 * d8_6[4] + 4 * d8_6[5] + 8 * d8_6[6] + 16 * d8_6[7] + 32 * d8_7[0] + 64 * d8_7[1] + 128 * d8_7[2]),
+        u8_from_field_unsafe(d8_7[3] + 2 * d8_7[4] + 4 * d8_7[5] + 8 * d8_7[6] + 16 * d8_7[7] + 32 * d8_0[0] + 64 * d8_0[1] + 128 * d8_0[2]),
+        u8_from_field_unsafe(d8_0[3] + 2 * d8_0[4] + 4 * d8_0[5] + 8 * d8_0[6] + 16 * d8_0[7] + 32 * d8_1[0] + 64 * d8_1[1] + 128 * d8_1[2]),
+        u8_from_field_unsafe(d8_1[3] + 2 * d8_1[4] + 4 * d8_1[5] + 8 * d8_1[6] + 16 * d8_1[7] + 32 * d8_2[0] + 64 * d8_2[1] + 128 * d8_2[2])
+      ];
+      -- b18 = rotl(t17, 15) = byte-rotl 1 + bit-shl 7
+      let d18_0 = u8_bit_decomposition(t17[0]);
+      let d18_1 = u8_bit_decomposition(t17[1]);
+      let d18_2 = u8_bit_decomposition(t17[2]);
+      let d18_3 = u8_bit_decomposition(t17[3]);
+      let d18_4 = u8_bit_decomposition(t17[4]);
+      let d18_5 = u8_bit_decomposition(t17[5]);
+      let d18_6 = u8_bit_decomposition(t17[6]);
+      let d18_7 = u8_bit_decomposition(t17[7]);
+      let b18 = [
+        u8_from_field_unsafe(d18_6[1] + 2 * d18_6[2] + 4 * d18_6[3] + 8 * d18_6[4] + 16 * d18_6[5] + 32 * d18_6[6] + 64 * d18_6[7] + 128 * d18_7[0]),
+        u8_from_field_unsafe(d18_7[1] + 2 * d18_7[2] + 4 * d18_7[3] + 8 * d18_7[4] + 16 * d18_7[5] + 32 * d18_7[6] + 64 * d18_7[7] + 128 * d18_0[0]),
+        u8_from_field_unsafe(d18_0[1] + 2 * d18_0[2] + 4 * d18_0[3] + 8 * d18_0[4] + 16 * d18_0[5] + 32 * d18_0[6] + 64 * d18_0[7] + 128 * d18_1[0]),
+        u8_from_field_unsafe(d18_1[1] + 2 * d18_1[2] + 4 * d18_1[3] + 8 * d18_1[4] + 16 * d18_1[5] + 32 * d18_1[6] + 64 * d18_1[7] + 128 * d18_2[0]),
+        u8_from_field_unsafe(d18_2[1] + 2 * d18_2[2] + 4 * d18_2[3] + 8 * d18_2[4] + 16 * d18_2[5] + 32 * d18_2[6] + 64 * d18_2[7] + 128 * d18_3[0]),
+        u8_from_field_unsafe(d18_3[1] + 2 * d18_3[2] + 4 * d18_3[3] + 8 * d18_3[4] + 16 * d18_3[5] + 32 * d18_3[6] + 64 * d18_3[7] + 128 * d18_4[0]),
+        u8_from_field_unsafe(d18_4[1] + 2 * d18_4[2] + 4 * d18_4[3] + 8 * d18_4[4] + 16 * d18_4[5] + 32 * d18_4[6] + 64 * d18_4[7] + 128 * d18_5[0]),
+        u8_from_field_unsafe(d18_5[1] + 2 * d18_5[2] + 4 * d18_5[3] + 8 * d18_5[4] + 16 * d18_5[5] + 32 * d18_5[6] + 64 * d18_5[7] + 128 * d18_6[0])
+      ];
+      -- b3 = rotl(t18, 21) = byte-rotl 2 + bit-shl 5
+      let d3_0 = u8_bit_decomposition(t18[0]);
+      let d3_1 = u8_bit_decomposition(t18[1]);
+      let d3_2 = u8_bit_decomposition(t18[2]);
+      let d3_3 = u8_bit_decomposition(t18[3]);
+      let d3_4 = u8_bit_decomposition(t18[4]);
+      let d3_5 = u8_bit_decomposition(t18[5]);
+      let d3_6 = u8_bit_decomposition(t18[6]);
+      let d3_7 = u8_bit_decomposition(t18[7]);
+      let b3 = [
+        u8_from_field_unsafe(d3_5[3] + 2 * d3_5[4] + 4 * d3_5[5] + 8 * d3_5[6] + 16 * d3_5[7] + 32 * d3_6[0] + 64 * d3_6[1] + 128 * d3_6[2]),
+        u8_from_field_unsafe(d3_6[3] + 2 * d3_6[4] + 4 * d3_6[5] + 8 * d3_6[6] + 16 * d3_6[7] + 32 * d3_7[0] + 64 * d3_7[1] + 128 * d3_7[2]),
+        u8_from_field_unsafe(d3_7[3] + 2 * d3_7[4] + 4 * d3_7[5] + 8 * d3_7[6] + 16 * d3_7[7] + 32 * d3_0[0] + 64 * d3_0[1] + 128 * d3_0[2]),
+        u8_from_field_unsafe(d3_0[3] + 2 * d3_0[4] + 4 * d3_0[5] + 8 * d3_0[6] + 16 * d3_0[7] + 32 * d3_1[0] + 64 * d3_1[1] + 128 * d3_1[2]),
+        u8_from_field_unsafe(d3_1[3] + 2 * d3_1[4] + 4 * d3_1[5] + 8 * d3_1[6] + 16 * d3_1[7] + 32 * d3_2[0] + 64 * d3_2[1] + 128 * d3_2[2]),
+        u8_from_field_unsafe(d3_2[3] + 2 * d3_2[4] + 4 * d3_2[5] + 8 * d3_2[6] + 16 * d3_2[7] + 32 * d3_3[0] + 64 * d3_3[1] + 128 * d3_3[2]),
+        u8_from_field_unsafe(d3_3[3] + 2 * d3_3[4] + 4 * d3_3[5] + 8 * d3_3[6] + 16 * d3_3[7] + 32 * d3_4[0] + 64 * d3_4[1] + 128 * d3_4[2]),
+        u8_from_field_unsafe(d3_4[3] + 2 * d3_4[4] + 4 * d3_4[5] + 8 * d3_4[6] + 16 * d3_4[7] + 32 * d3_5[0] + 64 * d3_5[1] + 128 * d3_5[2])
+      ];
+      -- b13 = rotl(t19, 8): byte rotation only (free)
+      let b13 = [t19[7], t19[0], t19[1], t19[2], t19[3], t19[4], t19[5], t19[6]];
+      -- b14 = rotl(t20, 18) = byte-rotl 2 + bit-shl 2
+      let d14_0 = u8_bit_decomposition(t20[0]);
+      let d14_1 = u8_bit_decomposition(t20[1]);
+      let d14_2 = u8_bit_decomposition(t20[2]);
+      let d14_3 = u8_bit_decomposition(t20[3]);
+      let d14_4 = u8_bit_decomposition(t20[4]);
+      let d14_5 = u8_bit_decomposition(t20[5]);
+      let d14_6 = u8_bit_decomposition(t20[6]);
+      let d14_7 = u8_bit_decomposition(t20[7]);
+      let b14 = [
+        u8_from_field_unsafe(d14_5[6] + 2 * d14_5[7] + 4 * d14_6[0] + 8 * d14_6[1] + 16 * d14_6[2] + 32 * d14_6[3] + 64 * d14_6[4] + 128 * d14_6[5]),
+        u8_from_field_unsafe(d14_6[6] + 2 * d14_6[7] + 4 * d14_7[0] + 8 * d14_7[1] + 16 * d14_7[2] + 32 * d14_7[3] + 64 * d14_7[4] + 128 * d14_7[5]),
+        u8_from_field_unsafe(d14_7[6] + 2 * d14_7[7] + 4 * d14_0[0] + 8 * d14_0[1] + 16 * d14_0[2] + 32 * d14_0[3] + 64 * d14_0[4] + 128 * d14_0[5]),
+        u8_from_field_unsafe(d14_0[6] + 2 * d14_0[7] + 4 * d14_1[0] + 8 * d14_1[1] + 16 * d14_1[2] + 32 * d14_1[3] + 64 * d14_1[4] + 128 * d14_1[5]),
+        u8_from_field_unsafe(d14_1[6] + 2 * d14_1[7] + 4 * d14_2[0] + 8 * d14_2[1] + 16 * d14_2[2] + 32 * d14_2[3] + 64 * d14_2[4] + 128 * d14_2[5]),
+        u8_from_field_unsafe(d14_2[6] + 2 * d14_2[7] + 4 * d14_3[0] + 8 * d14_3[1] + 16 * d14_3[2] + 32 * d14_3[3] + 64 * d14_3[4] + 128 * d14_3[5]),
+        u8_from_field_unsafe(d14_3[6] + 2 * d14_3[7] + 4 * d14_4[0] + 8 * d14_4[1] + 16 * d14_4[2] + 32 * d14_4[3] + 64 * d14_4[4] + 128 * d14_4[5]),
+        u8_from_field_unsafe(d14_4[6] + 2 * d14_4[7] + 4 * d14_5[0] + 8 * d14_5[1] + 16 * d14_5[2] + 32 * d14_5[3] + 64 * d14_5[4] + 128 * d14_5[5])
+      ];
+      -- b24 = rotl(t21, 2) = byte-rotl 0 + bit-shl 2
+      let d24_0 = u8_bit_decomposition(t21[0]);
+      let d24_1 = u8_bit_decomposition(t21[1]);
+      let d24_2 = u8_bit_decomposition(t21[2]);
+      let d24_3 = u8_bit_decomposition(t21[3]);
+      let d24_4 = u8_bit_decomposition(t21[4]);
+      let d24_5 = u8_bit_decomposition(t21[5]);
+      let d24_6 = u8_bit_decomposition(t21[6]);
+      let d24_7 = u8_bit_decomposition(t21[7]);
+      let b24 = [
+        u8_from_field_unsafe(d24_7[6] + 2 * d24_7[7] + 4 * d24_0[0] + 8 * d24_0[1] + 16 * d24_0[2] + 32 * d24_0[3] + 64 * d24_0[4] + 128 * d24_0[5]),
+        u8_from_field_unsafe(d24_0[6] + 2 * d24_0[7] + 4 * d24_1[0] + 8 * d24_1[1] + 16 * d24_1[2] + 32 * d24_1[3] + 64 * d24_1[4] + 128 * d24_1[5]),
+        u8_from_field_unsafe(d24_1[6] + 2 * d24_1[7] + 4 * d24_2[0] + 8 * d24_2[1] + 16 * d24_2[2] + 32 * d24_2[3] + 64 * d24_2[4] + 128 * d24_2[5]),
+        u8_from_field_unsafe(d24_2[6] + 2 * d24_2[7] + 4 * d24_3[0] + 8 * d24_3[1] + 16 * d24_3[2] + 32 * d24_3[3] + 64 * d24_3[4] + 128 * d24_3[5]),
+        u8_from_field_unsafe(d24_3[6] + 2 * d24_3[7] + 4 * d24_4[0] + 8 * d24_4[1] + 16 * d24_4[2] + 32 * d24_4[3] + 64 * d24_4[4] + 128 * d24_4[5]),
+        u8_from_field_unsafe(d24_4[6] + 2 * d24_4[7] + 4 * d24_5[0] + 8 * d24_5[1] + 16 * d24_5[2] + 32 * d24_5[3] + 64 * d24_5[4] + 128 * d24_5[5]),
+        u8_from_field_unsafe(d24_5[6] + 2 * d24_5[7] + 4 * d24_6[0] + 8 * d24_6[1] + 16 * d24_6[2] + 32 * d24_6[3] + 64 * d24_6[4] + 128 * d24_6[5]),
+        u8_from_field_unsafe(d24_6[6] + 2 * d24_6[7] + 4 * d24_7[0] + 8 * d24_7[1] + 16 * d24_7[2] + 32 * d24_7[3] + 64 * d24_7[4] + 128 * d24_7[5])
+      ];
+      -- b9 = rotl(t22, 61) = byte-rotl 7 + bit-shl 5
+      let d9_0 = u8_bit_decomposition(t22[0]);
+      let d9_1 = u8_bit_decomposition(t22[1]);
+      let d9_2 = u8_bit_decomposition(t22[2]);
+      let d9_3 = u8_bit_decomposition(t22[3]);
+      let d9_4 = u8_bit_decomposition(t22[4]);
+      let d9_5 = u8_bit_decomposition(t22[5]);
+      let d9_6 = u8_bit_decomposition(t22[6]);
+      let d9_7 = u8_bit_decomposition(t22[7]);
+      let b9 = [
+        u8_from_field_unsafe(d9_0[3] + 2 * d9_0[4] + 4 * d9_0[5] + 8 * d9_0[6] + 16 * d9_0[7] + 32 * d9_1[0] + 64 * d9_1[1] + 128 * d9_1[2]),
+        u8_from_field_unsafe(d9_1[3] + 2 * d9_1[4] + 4 * d9_1[5] + 8 * d9_1[6] + 16 * d9_1[7] + 32 * d9_2[0] + 64 * d9_2[1] + 128 * d9_2[2]),
+        u8_from_field_unsafe(d9_2[3] + 2 * d9_2[4] + 4 * d9_2[5] + 8 * d9_2[6] + 16 * d9_2[7] + 32 * d9_3[0] + 64 * d9_3[1] + 128 * d9_3[2]),
+        u8_from_field_unsafe(d9_3[3] + 2 * d9_3[4] + 4 * d9_3[5] + 8 * d9_3[6] + 16 * d9_3[7] + 32 * d9_4[0] + 64 * d9_4[1] + 128 * d9_4[2]),
+        u8_from_field_unsafe(d9_4[3] + 2 * d9_4[4] + 4 * d9_4[5] + 8 * d9_4[6] + 16 * d9_4[7] + 32 * d9_5[0] + 64 * d9_5[1] + 128 * d9_5[2]),
+        u8_from_field_unsafe(d9_5[3] + 2 * d9_5[4] + 4 * d9_5[5] + 8 * d9_5[6] + 16 * d9_5[7] + 32 * d9_6[0] + 64 * d9_6[1] + 128 * d9_6[2]),
+        u8_from_field_unsafe(d9_6[3] + 2 * d9_6[4] + 4 * d9_6[5] + 8 * d9_6[6] + 16 * d9_6[7] + 32 * d9_7[0] + 64 * d9_7[1] + 128 * d9_7[2]),
+        u8_from_field_unsafe(d9_7[3] + 2 * d9_7[4] + 4 * d9_7[5] + 8 * d9_7[6] + 16 * d9_7[7] + 32 * d9_0[0] + 64 * d9_0[1] + 128 * d9_0[2])
+      ];
+      -- b19 = rotl(t23, 56): byte rotation only (free)
+      let b19 = [t23[1], t23[2], t23[3], t23[4], t23[5], t23[6], t23[7], t23[0]];
+      -- b4 = rotl(t24, 14) = byte-rotl 1 + bit-shl 6
+      let d4_0 = u8_bit_decomposition(t24[0]);
+      let d4_1 = u8_bit_decomposition(t24[1]);
+      let d4_2 = u8_bit_decomposition(t24[2]);
+      let d4_3 = u8_bit_decomposition(t24[3]);
+      let d4_4 = u8_bit_decomposition(t24[4]);
+      let d4_5 = u8_bit_decomposition(t24[5]);
+      let d4_6 = u8_bit_decomposition(t24[6]);
+      let d4_7 = u8_bit_decomposition(t24[7]);
+      let b4 = [
+        u8_from_field_unsafe(d4_6[2] + 2 * d4_6[3] + 4 * d4_6[4] + 8 * d4_6[5] + 16 * d4_6[6] + 32 * d4_6[7] + 64 * d4_7[0] + 128 * d4_7[1]),
+        u8_from_field_unsafe(d4_7[2] + 2 * d4_7[3] + 4 * d4_7[4] + 8 * d4_7[5] + 16 * d4_7[6] + 32 * d4_7[7] + 64 * d4_0[0] + 128 * d4_0[1]),
+        u8_from_field_unsafe(d4_0[2] + 2 * d4_0[3] + 4 * d4_0[4] + 8 * d4_0[5] + 16 * d4_0[6] + 32 * d4_0[7] + 64 * d4_1[0] + 128 * d4_1[1]),
+        u8_from_field_unsafe(d4_1[2] + 2 * d4_1[3] + 4 * d4_1[4] + 8 * d4_1[5] + 16 * d4_1[6] + 32 * d4_1[7] + 64 * d4_2[0] + 128 * d4_2[1]),
+        u8_from_field_unsafe(d4_2[2] + 2 * d4_2[3] + 4 * d4_2[4] + 8 * d4_2[5] + 16 * d4_2[6] + 32 * d4_2[7] + 64 * d4_3[0] + 128 * d4_3[1]),
+        u8_from_field_unsafe(d4_3[2] + 2 * d4_3[3] + 4 * d4_3[4] + 8 * d4_3[5] + 16 * d4_3[6] + 32 * d4_3[7] + 64 * d4_4[0] + 128 * d4_4[1]),
+        u8_from_field_unsafe(d4_4[2] + 2 * d4_4[3] + 4 * d4_4[4] + 8 * d4_4[5] + 16 * d4_4[6] + 32 * d4_4[7] + 64 * d4_5[0] + 128 * d4_5[1]),
+        u8_from_field_unsafe(d4_5[2] + 2 * d4_5[3] + 4 * d4_5[4] + 8 * d4_5[5] + 16 * d4_5[6] + 32 * d4_5[7] + 64 * d4_6[0] + 128 * d4_6[1])
+      ];
+      -- chi: e[x,y] = b[x,y] ^ (~b[x+1,y] & b[x+2,y]); NOT is the free
+      -- recomposition 255 - b.
+      let e0 = [u8_xor(b0[0], u8_and(u8_from_field_unsafe(255 - to_field(b1[0])), b2[0])), u8_xor(b0[1], u8_and(u8_from_field_unsafe(255 - to_field(b1[1])), b2[1])), u8_xor(b0[2], u8_and(u8_from_field_unsafe(255 - to_field(b1[2])), b2[2])), u8_xor(b0[3], u8_and(u8_from_field_unsafe(255 - to_field(b1[3])), b2[3])), u8_xor(b0[4], u8_and(u8_from_field_unsafe(255 - to_field(b1[4])), b2[4])), u8_xor(b0[5], u8_and(u8_from_field_unsafe(255 - to_field(b1[5])), b2[5])), u8_xor(b0[6], u8_and(u8_from_field_unsafe(255 - to_field(b1[6])), b2[6])), u8_xor(b0[7], u8_and(u8_from_field_unsafe(255 - to_field(b1[7])), b2[7]))];
+      let e1 = [u8_xor(b1[0], u8_and(u8_from_field_unsafe(255 - to_field(b2[0])), b3[0])), u8_xor(b1[1], u8_and(u8_from_field_unsafe(255 - to_field(b2[1])), b3[1])), u8_xor(b1[2], u8_and(u8_from_field_unsafe(255 - to_field(b2[2])), b3[2])), u8_xor(b1[3], u8_and(u8_from_field_unsafe(255 - to_field(b2[3])), b3[3])), u8_xor(b1[4], u8_and(u8_from_field_unsafe(255 - to_field(b2[4])), b3[4])), u8_xor(b1[5], u8_and(u8_from_field_unsafe(255 - to_field(b2[5])), b3[5])), u8_xor(b1[6], u8_and(u8_from_field_unsafe(255 - to_field(b2[6])), b3[6])), u8_xor(b1[7], u8_and(u8_from_field_unsafe(255 - to_field(b2[7])), b3[7]))];
+      let e2 = [u8_xor(b2[0], u8_and(u8_from_field_unsafe(255 - to_field(b3[0])), b4[0])), u8_xor(b2[1], u8_and(u8_from_field_unsafe(255 - to_field(b3[1])), b4[1])), u8_xor(b2[2], u8_and(u8_from_field_unsafe(255 - to_field(b3[2])), b4[2])), u8_xor(b2[3], u8_and(u8_from_field_unsafe(255 - to_field(b3[3])), b4[3])), u8_xor(b2[4], u8_and(u8_from_field_unsafe(255 - to_field(b3[4])), b4[4])), u8_xor(b2[5], u8_and(u8_from_field_unsafe(255 - to_field(b3[5])), b4[5])), u8_xor(b2[6], u8_and(u8_from_field_unsafe(255 - to_field(b3[6])), b4[6])), u8_xor(b2[7], u8_and(u8_from_field_unsafe(255 - to_field(b3[7])), b4[7]))];
+      let e3 = [u8_xor(b3[0], u8_and(u8_from_field_unsafe(255 - to_field(b4[0])), b0[0])), u8_xor(b3[1], u8_and(u8_from_field_unsafe(255 - to_field(b4[1])), b0[1])), u8_xor(b3[2], u8_and(u8_from_field_unsafe(255 - to_field(b4[2])), b0[2])), u8_xor(b3[3], u8_and(u8_from_field_unsafe(255 - to_field(b4[3])), b0[3])), u8_xor(b3[4], u8_and(u8_from_field_unsafe(255 - to_field(b4[4])), b0[4])), u8_xor(b3[5], u8_and(u8_from_field_unsafe(255 - to_field(b4[5])), b0[5])), u8_xor(b3[6], u8_and(u8_from_field_unsafe(255 - to_field(b4[6])), b0[6])), u8_xor(b3[7], u8_and(u8_from_field_unsafe(255 - to_field(b4[7])), b0[7]))];
+      let e4 = [u8_xor(b4[0], u8_and(u8_from_field_unsafe(255 - to_field(b0[0])), b1[0])), u8_xor(b4[1], u8_and(u8_from_field_unsafe(255 - to_field(b0[1])), b1[1])), u8_xor(b4[2], u8_and(u8_from_field_unsafe(255 - to_field(b0[2])), b1[2])), u8_xor(b4[3], u8_and(u8_from_field_unsafe(255 - to_field(b0[3])), b1[3])), u8_xor(b4[4], u8_and(u8_from_field_unsafe(255 - to_field(b0[4])), b1[4])), u8_xor(b4[5], u8_and(u8_from_field_unsafe(255 - to_field(b0[5])), b1[5])), u8_xor(b4[6], u8_and(u8_from_field_unsafe(255 - to_field(b0[6])), b1[6])), u8_xor(b4[7], u8_and(u8_from_field_unsafe(255 - to_field(b0[7])), b1[7]))];
+      let e5 = [u8_xor(b5[0], u8_and(u8_from_field_unsafe(255 - to_field(b6[0])), b7[0])), u8_xor(b5[1], u8_and(u8_from_field_unsafe(255 - to_field(b6[1])), b7[1])), u8_xor(b5[2], u8_and(u8_from_field_unsafe(255 - to_field(b6[2])), b7[2])), u8_xor(b5[3], u8_and(u8_from_field_unsafe(255 - to_field(b6[3])), b7[3])), u8_xor(b5[4], u8_and(u8_from_field_unsafe(255 - to_field(b6[4])), b7[4])), u8_xor(b5[5], u8_and(u8_from_field_unsafe(255 - to_field(b6[5])), b7[5])), u8_xor(b5[6], u8_and(u8_from_field_unsafe(255 - to_field(b6[6])), b7[6])), u8_xor(b5[7], u8_and(u8_from_field_unsafe(255 - to_field(b6[7])), b7[7]))];
+      let e6 = [u8_xor(b6[0], u8_and(u8_from_field_unsafe(255 - to_field(b7[0])), b8[0])), u8_xor(b6[1], u8_and(u8_from_field_unsafe(255 - to_field(b7[1])), b8[1])), u8_xor(b6[2], u8_and(u8_from_field_unsafe(255 - to_field(b7[2])), b8[2])), u8_xor(b6[3], u8_and(u8_from_field_unsafe(255 - to_field(b7[3])), b8[3])), u8_xor(b6[4], u8_and(u8_from_field_unsafe(255 - to_field(b7[4])), b8[4])), u8_xor(b6[5], u8_and(u8_from_field_unsafe(255 - to_field(b7[5])), b8[5])), u8_xor(b6[6], u8_and(u8_from_field_unsafe(255 - to_field(b7[6])), b8[6])), u8_xor(b6[7], u8_and(u8_from_field_unsafe(255 - to_field(b7[7])), b8[7]))];
+      let e7 = [u8_xor(b7[0], u8_and(u8_from_field_unsafe(255 - to_field(b8[0])), b9[0])), u8_xor(b7[1], u8_and(u8_from_field_unsafe(255 - to_field(b8[1])), b9[1])), u8_xor(b7[2], u8_and(u8_from_field_unsafe(255 - to_field(b8[2])), b9[2])), u8_xor(b7[3], u8_and(u8_from_field_unsafe(255 - to_field(b8[3])), b9[3])), u8_xor(b7[4], u8_and(u8_from_field_unsafe(255 - to_field(b8[4])), b9[4])), u8_xor(b7[5], u8_and(u8_from_field_unsafe(255 - to_field(b8[5])), b9[5])), u8_xor(b7[6], u8_and(u8_from_field_unsafe(255 - to_field(b8[6])), b9[6])), u8_xor(b7[7], u8_and(u8_from_field_unsafe(255 - to_field(b8[7])), b9[7]))];
+      let e8 = [u8_xor(b8[0], u8_and(u8_from_field_unsafe(255 - to_field(b9[0])), b5[0])), u8_xor(b8[1], u8_and(u8_from_field_unsafe(255 - to_field(b9[1])), b5[1])), u8_xor(b8[2], u8_and(u8_from_field_unsafe(255 - to_field(b9[2])), b5[2])), u8_xor(b8[3], u8_and(u8_from_field_unsafe(255 - to_field(b9[3])), b5[3])), u8_xor(b8[4], u8_and(u8_from_field_unsafe(255 - to_field(b9[4])), b5[4])), u8_xor(b8[5], u8_and(u8_from_field_unsafe(255 - to_field(b9[5])), b5[5])), u8_xor(b8[6], u8_and(u8_from_field_unsafe(255 - to_field(b9[6])), b5[6])), u8_xor(b8[7], u8_and(u8_from_field_unsafe(255 - to_field(b9[7])), b5[7]))];
+      let e9 = [u8_xor(b9[0], u8_and(u8_from_field_unsafe(255 - to_field(b5[0])), b6[0])), u8_xor(b9[1], u8_and(u8_from_field_unsafe(255 - to_field(b5[1])), b6[1])), u8_xor(b9[2], u8_and(u8_from_field_unsafe(255 - to_field(b5[2])), b6[2])), u8_xor(b9[3], u8_and(u8_from_field_unsafe(255 - to_field(b5[3])), b6[3])), u8_xor(b9[4], u8_and(u8_from_field_unsafe(255 - to_field(b5[4])), b6[4])), u8_xor(b9[5], u8_and(u8_from_field_unsafe(255 - to_field(b5[5])), b6[5])), u8_xor(b9[6], u8_and(u8_from_field_unsafe(255 - to_field(b5[6])), b6[6])), u8_xor(b9[7], u8_and(u8_from_field_unsafe(255 - to_field(b5[7])), b6[7]))];
+      let e10 = [u8_xor(b10[0], u8_and(u8_from_field_unsafe(255 - to_field(b11[0])), b12[0])), u8_xor(b10[1], u8_and(u8_from_field_unsafe(255 - to_field(b11[1])), b12[1])), u8_xor(b10[2], u8_and(u8_from_field_unsafe(255 - to_field(b11[2])), b12[2])), u8_xor(b10[3], u8_and(u8_from_field_unsafe(255 - to_field(b11[3])), b12[3])), u8_xor(b10[4], u8_and(u8_from_field_unsafe(255 - to_field(b11[4])), b12[4])), u8_xor(b10[5], u8_and(u8_from_field_unsafe(255 - to_field(b11[5])), b12[5])), u8_xor(b10[6], u8_and(u8_from_field_unsafe(255 - to_field(b11[6])), b12[6])), u8_xor(b10[7], u8_and(u8_from_field_unsafe(255 - to_field(b11[7])), b12[7]))];
+      let e11 = [u8_xor(b11[0], u8_and(u8_from_field_unsafe(255 - to_field(b12[0])), b13[0])), u8_xor(b11[1], u8_and(u8_from_field_unsafe(255 - to_field(b12[1])), b13[1])), u8_xor(b11[2], u8_and(u8_from_field_unsafe(255 - to_field(b12[2])), b13[2])), u8_xor(b11[3], u8_and(u8_from_field_unsafe(255 - to_field(b12[3])), b13[3])), u8_xor(b11[4], u8_and(u8_from_field_unsafe(255 - to_field(b12[4])), b13[4])), u8_xor(b11[5], u8_and(u8_from_field_unsafe(255 - to_field(b12[5])), b13[5])), u8_xor(b11[6], u8_and(u8_from_field_unsafe(255 - to_field(b12[6])), b13[6])), u8_xor(b11[7], u8_and(u8_from_field_unsafe(255 - to_field(b12[7])), b13[7]))];
+      let e12 = [u8_xor(b12[0], u8_and(u8_from_field_unsafe(255 - to_field(b13[0])), b14[0])), u8_xor(b12[1], u8_and(u8_from_field_unsafe(255 - to_field(b13[1])), b14[1])), u8_xor(b12[2], u8_and(u8_from_field_unsafe(255 - to_field(b13[2])), b14[2])), u8_xor(b12[3], u8_and(u8_from_field_unsafe(255 - to_field(b13[3])), b14[3])), u8_xor(b12[4], u8_and(u8_from_field_unsafe(255 - to_field(b13[4])), b14[4])), u8_xor(b12[5], u8_and(u8_from_field_unsafe(255 - to_field(b13[5])), b14[5])), u8_xor(b12[6], u8_and(u8_from_field_unsafe(255 - to_field(b13[6])), b14[6])), u8_xor(b12[7], u8_and(u8_from_field_unsafe(255 - to_field(b13[7])), b14[7]))];
+      let e13 = [u8_xor(b13[0], u8_and(u8_from_field_unsafe(255 - to_field(b14[0])), b10[0])), u8_xor(b13[1], u8_and(u8_from_field_unsafe(255 - to_field(b14[1])), b10[1])), u8_xor(b13[2], u8_and(u8_from_field_unsafe(255 - to_field(b14[2])), b10[2])), u8_xor(b13[3], u8_and(u8_from_field_unsafe(255 - to_field(b14[3])), b10[3])), u8_xor(b13[4], u8_and(u8_from_field_unsafe(255 - to_field(b14[4])), b10[4])), u8_xor(b13[5], u8_and(u8_from_field_unsafe(255 - to_field(b14[5])), b10[5])), u8_xor(b13[6], u8_and(u8_from_field_unsafe(255 - to_field(b14[6])), b10[6])), u8_xor(b13[7], u8_and(u8_from_field_unsafe(255 - to_field(b14[7])), b10[7]))];
+      let e14 = [u8_xor(b14[0], u8_and(u8_from_field_unsafe(255 - to_field(b10[0])), b11[0])), u8_xor(b14[1], u8_and(u8_from_field_unsafe(255 - to_field(b10[1])), b11[1])), u8_xor(b14[2], u8_and(u8_from_field_unsafe(255 - to_field(b10[2])), b11[2])), u8_xor(b14[3], u8_and(u8_from_field_unsafe(255 - to_field(b10[3])), b11[3])), u8_xor(b14[4], u8_and(u8_from_field_unsafe(255 - to_field(b10[4])), b11[4])), u8_xor(b14[5], u8_and(u8_from_field_unsafe(255 - to_field(b10[5])), b11[5])), u8_xor(b14[6], u8_and(u8_from_field_unsafe(255 - to_field(b10[6])), b11[6])), u8_xor(b14[7], u8_and(u8_from_field_unsafe(255 - to_field(b10[7])), b11[7]))];
+      let e15 = [u8_xor(b15[0], u8_and(u8_from_field_unsafe(255 - to_field(b16[0])), b17[0])), u8_xor(b15[1], u8_and(u8_from_field_unsafe(255 - to_field(b16[1])), b17[1])), u8_xor(b15[2], u8_and(u8_from_field_unsafe(255 - to_field(b16[2])), b17[2])), u8_xor(b15[3], u8_and(u8_from_field_unsafe(255 - to_field(b16[3])), b17[3])), u8_xor(b15[4], u8_and(u8_from_field_unsafe(255 - to_field(b16[4])), b17[4])), u8_xor(b15[5], u8_and(u8_from_field_unsafe(255 - to_field(b16[5])), b17[5])), u8_xor(b15[6], u8_and(u8_from_field_unsafe(255 - to_field(b16[6])), b17[6])), u8_xor(b15[7], u8_and(u8_from_field_unsafe(255 - to_field(b16[7])), b17[7]))];
+      let e16 = [u8_xor(b16[0], u8_and(u8_from_field_unsafe(255 - to_field(b17[0])), b18[0])), u8_xor(b16[1], u8_and(u8_from_field_unsafe(255 - to_field(b17[1])), b18[1])), u8_xor(b16[2], u8_and(u8_from_field_unsafe(255 - to_field(b17[2])), b18[2])), u8_xor(b16[3], u8_and(u8_from_field_unsafe(255 - to_field(b17[3])), b18[3])), u8_xor(b16[4], u8_and(u8_from_field_unsafe(255 - to_field(b17[4])), b18[4])), u8_xor(b16[5], u8_and(u8_from_field_unsafe(255 - to_field(b17[5])), b18[5])), u8_xor(b16[6], u8_and(u8_from_field_unsafe(255 - to_field(b17[6])), b18[6])), u8_xor(b16[7], u8_and(u8_from_field_unsafe(255 - to_field(b17[7])), b18[7]))];
+      let e17 = [u8_xor(b17[0], u8_and(u8_from_field_unsafe(255 - to_field(b18[0])), b19[0])), u8_xor(b17[1], u8_and(u8_from_field_unsafe(255 - to_field(b18[1])), b19[1])), u8_xor(b17[2], u8_and(u8_from_field_unsafe(255 - to_field(b18[2])), b19[2])), u8_xor(b17[3], u8_and(u8_from_field_unsafe(255 - to_field(b18[3])), b19[3])), u8_xor(b17[4], u8_and(u8_from_field_unsafe(255 - to_field(b18[4])), b19[4])), u8_xor(b17[5], u8_and(u8_from_field_unsafe(255 - to_field(b18[5])), b19[5])), u8_xor(b17[6], u8_and(u8_from_field_unsafe(255 - to_field(b18[6])), b19[6])), u8_xor(b17[7], u8_and(u8_from_field_unsafe(255 - to_field(b18[7])), b19[7]))];
+      let e18 = [u8_xor(b18[0], u8_and(u8_from_field_unsafe(255 - to_field(b19[0])), b15[0])), u8_xor(b18[1], u8_and(u8_from_field_unsafe(255 - to_field(b19[1])), b15[1])), u8_xor(b18[2], u8_and(u8_from_field_unsafe(255 - to_field(b19[2])), b15[2])), u8_xor(b18[3], u8_and(u8_from_field_unsafe(255 - to_field(b19[3])), b15[3])), u8_xor(b18[4], u8_and(u8_from_field_unsafe(255 - to_field(b19[4])), b15[4])), u8_xor(b18[5], u8_and(u8_from_field_unsafe(255 - to_field(b19[5])), b15[5])), u8_xor(b18[6], u8_and(u8_from_field_unsafe(255 - to_field(b19[6])), b15[6])), u8_xor(b18[7], u8_and(u8_from_field_unsafe(255 - to_field(b19[7])), b15[7]))];
+      let e19 = [u8_xor(b19[0], u8_and(u8_from_field_unsafe(255 - to_field(b15[0])), b16[0])), u8_xor(b19[1], u8_and(u8_from_field_unsafe(255 - to_field(b15[1])), b16[1])), u8_xor(b19[2], u8_and(u8_from_field_unsafe(255 - to_field(b15[2])), b16[2])), u8_xor(b19[3], u8_and(u8_from_field_unsafe(255 - to_field(b15[3])), b16[3])), u8_xor(b19[4], u8_and(u8_from_field_unsafe(255 - to_field(b15[4])), b16[4])), u8_xor(b19[5], u8_and(u8_from_field_unsafe(255 - to_field(b15[5])), b16[5])), u8_xor(b19[6], u8_and(u8_from_field_unsafe(255 - to_field(b15[6])), b16[6])), u8_xor(b19[7], u8_and(u8_from_field_unsafe(255 - to_field(b15[7])), b16[7]))];
+      let e20 = [u8_xor(b20[0], u8_and(u8_from_field_unsafe(255 - to_field(b21[0])), b22[0])), u8_xor(b20[1], u8_and(u8_from_field_unsafe(255 - to_field(b21[1])), b22[1])), u8_xor(b20[2], u8_and(u8_from_field_unsafe(255 - to_field(b21[2])), b22[2])), u8_xor(b20[3], u8_and(u8_from_field_unsafe(255 - to_field(b21[3])), b22[3])), u8_xor(b20[4], u8_and(u8_from_field_unsafe(255 - to_field(b21[4])), b22[4])), u8_xor(b20[5], u8_and(u8_from_field_unsafe(255 - to_field(b21[5])), b22[5])), u8_xor(b20[6], u8_and(u8_from_field_unsafe(255 - to_field(b21[6])), b22[6])), u8_xor(b20[7], u8_and(u8_from_field_unsafe(255 - to_field(b21[7])), b22[7]))];
+      let e21 = [u8_xor(b21[0], u8_and(u8_from_field_unsafe(255 - to_field(b22[0])), b23[0])), u8_xor(b21[1], u8_and(u8_from_field_unsafe(255 - to_field(b22[1])), b23[1])), u8_xor(b21[2], u8_and(u8_from_field_unsafe(255 - to_field(b22[2])), b23[2])), u8_xor(b21[3], u8_and(u8_from_field_unsafe(255 - to_field(b22[3])), b23[3])), u8_xor(b21[4], u8_and(u8_from_field_unsafe(255 - to_field(b22[4])), b23[4])), u8_xor(b21[5], u8_and(u8_from_field_unsafe(255 - to_field(b22[5])), b23[5])), u8_xor(b21[6], u8_and(u8_from_field_unsafe(255 - to_field(b22[6])), b23[6])), u8_xor(b21[7], u8_and(u8_from_field_unsafe(255 - to_field(b22[7])), b23[7]))];
+      let e22 = [u8_xor(b22[0], u8_and(u8_from_field_unsafe(255 - to_field(b23[0])), b24[0])), u8_xor(b22[1], u8_and(u8_from_field_unsafe(255 - to_field(b23[1])), b24[1])), u8_xor(b22[2], u8_and(u8_from_field_unsafe(255 - to_field(b23[2])), b24[2])), u8_xor(b22[3], u8_and(u8_from_field_unsafe(255 - to_field(b23[3])), b24[3])), u8_xor(b22[4], u8_and(u8_from_field_unsafe(255 - to_field(b23[4])), b24[4])), u8_xor(b22[5], u8_and(u8_from_field_unsafe(255 - to_field(b23[5])), b24[5])), u8_xor(b22[6], u8_and(u8_from_field_unsafe(255 - to_field(b23[6])), b24[6])), u8_xor(b22[7], u8_and(u8_from_field_unsafe(255 - to_field(b23[7])), b24[7]))];
+      let e23 = [u8_xor(b23[0], u8_and(u8_from_field_unsafe(255 - to_field(b24[0])), b20[0])), u8_xor(b23[1], u8_and(u8_from_field_unsafe(255 - to_field(b24[1])), b20[1])), u8_xor(b23[2], u8_and(u8_from_field_unsafe(255 - to_field(b24[2])), b20[2])), u8_xor(b23[3], u8_and(u8_from_field_unsafe(255 - to_field(b24[3])), b20[3])), u8_xor(b23[4], u8_and(u8_from_field_unsafe(255 - to_field(b24[4])), b20[4])), u8_xor(b23[5], u8_and(u8_from_field_unsafe(255 - to_field(b24[5])), b20[5])), u8_xor(b23[6], u8_and(u8_from_field_unsafe(255 - to_field(b24[6])), b20[6])), u8_xor(b23[7], u8_and(u8_from_field_unsafe(255 - to_field(b24[7])), b20[7]))];
+      let e24 = [u8_xor(b24[0], u8_and(u8_from_field_unsafe(255 - to_field(b20[0])), b21[0])), u8_xor(b24[1], u8_and(u8_from_field_unsafe(255 - to_field(b20[1])), b21[1])), u8_xor(b24[2], u8_and(u8_from_field_unsafe(255 - to_field(b20[2])), b21[2])), u8_xor(b24[3], u8_and(u8_from_field_unsafe(255 - to_field(b20[3])), b21[3])), u8_xor(b24[4], u8_and(u8_from_field_unsafe(255 - to_field(b20[4])), b21[4])), u8_xor(b24[5], u8_and(u8_from_field_unsafe(255 - to_field(b20[5])), b21[5])), u8_xor(b24[6], u8_and(u8_from_field_unsafe(255 - to_field(b20[6])), b21[6])), u8_xor(b24[7], u8_and(u8_from_field_unsafe(255 - to_field(b20[7])), b21[7]))];
+      -- iota: xor the round constant into lane (0,0).
+      let f0 = [u8_xor(e0[0], rc[0]), u8_xor(e0[1], rc[1]), u8_xor(e0[2], rc[2]), u8_xor(e0[3], rc[3]), u8_xor(e0[4], rc[4]), u8_xor(e0[5], rc[5]), u8_xor(e0[6], rc[6]), u8_xor(e0[7], rc[7])];
+      [f0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24]
+  }
+⟧
+
+end IxVM
+
+end
diff --git a/Tests/Aiur/Hashes.lean b/Tests/Aiur/Hashes.lean
index 817b6351..cadb2b71 100644
--- a/Tests/Aiur/Hashes.lean
+++ b/Tests/Aiur/Hashes.lean
@@ -4,6 +4,8 @@ public import Tests.Aiur.Common
 public import Ix.IxVM.ByteStream
 public import Ix.IxVM.Blake3
 public import Ix.IxVM.Sha256
+public import Ix.IxVM.Keccak
+public import Ix.Keccak
 public import Tests.Sha256
 public import Blake3.Rust
 
@@ -31,6 +33,33 @@ def mkSha256HashTestCase (size : Nat) : AiurTestCase :=
     expectedOutput := output, inputIOBuffer := buffer, expectedIOBuffer := buffer
     interpret := false }
 
+def mkKeccakHashTestCase (size : Nat) : AiurTestCase :=
+  let inputBytes := Array.range size |>.map Nat.toUInt8
+  let outputBytes := (Keccak.hash ⟨inputBytes⟩).data
+  let input := inputBytes.map .ofUInt8
+  let output := outputBytes.map .ofUInt8
+  let buffer : Aiur.IOBuffer :=
+    ⟨.ofList [(0, input)], .ofList [((0, #[0]), ⟨0, size⟩)]⟩
+  { functionName := `keccak256_test, label := s!"keccak256 (size={size})"
+    expectedOutput := output, inputIOBuffer := buffer, expectedIOBuffer := buffer
+    interpret := false }
+
+/-- Rate-boundary coverage: 135/136/137 straddle one 136-byte rate block
+    (135 pads in-block, 136 forces the extra all-padding block, 137 spills
+    into a second block), 271/272/273 the same around two blocks. -/
+public def keccakTestCases : List AiurTestCase := [
+  mkKeccakHashTestCase 0,
+  mkKeccakHashTestCase 1,
+  mkKeccakHashTestCase 32,
+  mkKeccakHashTestCase 135,
+  mkKeccakHashTestCase 136,
+  mkKeccakHashTestCase 137,
+  mkKeccakHashTestCase 271,
+  mkKeccakHashTestCase 272,
+  mkKeccakHashTestCase 273,
+  mkKeccakHashTestCase 1200,
+]
+
 public def blake3TestCases : List AiurTestCase := [
   mkBlake3HashTestCase 0,
   mkBlake3HashTestCase 32,
diff --git a/Tests/Main.lean b/Tests/Main.lean
index 8a1eebd0..6c97143d 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -92,7 +92,11 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [
         let t ← IxVM.core.merge IxVM.byteStream; t.merge IxVM.sha256)
       | IO.eprintln "SHA256 setup failed"; return 1
     let r2 ← LSpec.lspecEachIO sha256TestCases fun tc => pure (sha256Env.runTestCase tc)
-    return if r1 == 0 && r2 == 0 then 0 else 1),
+    let .ok keccakEnv := AiurTestEnv.build (do
+        let t ← IxVM.core.merge IxVM.byteStream; t.merge IxVM.keccak)
+      | IO.eprintln "Keccak setup failed"; return 1
+    let r3 ← LSpec.lspecEachIO keccakTestCases fun tc => pure (keccakEnv.runTestCase tc)
+    return if r1 == 0 && r2 == 0 && r3 == 0 then 0 else 1),
   ("ixvm", do
     let kernelUnitTests := .exec `kernel_unit_tests
     let serdeNatAddCommTest ← serdeNatAddComm env

From 63de2f03b4c93f658748ca9a86ee5b0176fb2e25 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sat, 11 Jul 2026 08:15:54 -0700
Subject: [PATCH 10/22] Aiur keccak: cheap rho rotations for non-{0,4}
 bit-shifts

A lane rotation by 8q+s previously always paid 8 u8_bit_decompositions
(64 aux + 8 lookups) regardless of s. Only s=4 genuinely needs the
decomposition. For s in {1,2,3}, chain rotl-by-1 via the u8_add
doubling trick already used in theta ((b+b) = (2b mod 256, msb); the
even low byte absorbs the neighbor's msb through a free field add), 8
aux+lookups per step. For s in {5,6,7}, chain rotr-by-1 via
u8_shift_right (the dropped lsb is recovered as b - 2*(b>>1) and
recomposed into the neighbor's high bit, also free). 18 of the 24
rotations take a cheaper path; only the six s in {0,4} keep the byte
shuffle / decomposition.

Probe (1 hash, 2048 bytes, non-periodic LCG): 18,105,233 ->
16,206,377 (-10.5%); keccak_rho_chi_iota width 3198 -> 2622.
`aiur-hashes` keccak cases green (rate boundaries 0..273 + 1200,
execute/claim/prove-verify) against the Rust FFI oracle.
---
 Ix/IxVM/Keccak.lean | 718 ++++++++++++++++++++------------------------
 1 file changed, 332 insertions(+), 386 deletions(-)

diff --git a/Ix/IxVM/Keccak.lean b/Ix/IxVM/Keccak.lean
index 694abd5a..063bef59 100644
--- a/Ix/IxVM/Keccak.lean
+++ b/Ix/IxVM/Keccak.lean
@@ -349,45 +349,35 @@ def keccak := ⟦
       -- rho + pi: b[pi(src)] = rotl(t[src], rho(src)).
       -- b0 = rotl(t0, 0): byte rotation only (free)
       let b0 = [t0[0], t0[1], t0[2], t0[3], t0[4], t0[5], t0[6], t0[7]];
-      -- b10 = rotl(t1, 1) = byte-rotl 0 + bit-shl 1
-      let d10_0 = u8_bit_decomposition(t1[0]);
-      let d10_1 = u8_bit_decomposition(t1[1]);
-      let d10_2 = u8_bit_decomposition(t1[2]);
-      let d10_3 = u8_bit_decomposition(t1[3]);
-      let d10_4 = u8_bit_decomposition(t1[4]);
-      let d10_5 = u8_bit_decomposition(t1[5]);
-      let d10_6 = u8_bit_decomposition(t1[6]);
-      let d10_7 = u8_bit_decomposition(t1[7]);
-      let b10 = [
-        u8_from_field_unsafe(d10_7[7] + 2 * d10_0[0] + 4 * d10_0[1] + 8 * d10_0[2] + 16 * d10_0[3] + 32 * d10_0[4] + 64 * d10_0[5] + 128 * d10_0[6]),
-        u8_from_field_unsafe(d10_0[7] + 2 * d10_1[0] + 4 * d10_1[1] + 8 * d10_1[2] + 16 * d10_1[3] + 32 * d10_1[4] + 64 * d10_1[5] + 128 * d10_1[6]),
-        u8_from_field_unsafe(d10_1[7] + 2 * d10_2[0] + 4 * d10_2[1] + 8 * d10_2[2] + 16 * d10_2[3] + 32 * d10_2[4] + 64 * d10_2[5] + 128 * d10_2[6]),
-        u8_from_field_unsafe(d10_2[7] + 2 * d10_3[0] + 4 * d10_3[1] + 8 * d10_3[2] + 16 * d10_3[3] + 32 * d10_3[4] + 64 * d10_3[5] + 128 * d10_3[6]),
-        u8_from_field_unsafe(d10_3[7] + 2 * d10_4[0] + 4 * d10_4[1] + 8 * d10_4[2] + 16 * d10_4[3] + 32 * d10_4[4] + 64 * d10_4[5] + 128 * d10_4[6]),
-        u8_from_field_unsafe(d10_4[7] + 2 * d10_5[0] + 4 * d10_5[1] + 8 * d10_5[2] + 16 * d10_5[3] + 32 * d10_5[4] + 64 * d10_5[5] + 128 * d10_5[6]),
-        u8_from_field_unsafe(d10_5[7] + 2 * d10_6[0] + 4 * d10_6[1] + 8 * d10_6[2] + 16 * d10_6[3] + 32 * d10_6[4] + 64 * d10_6[5] + 128 * d10_6[6]),
-        u8_from_field_unsafe(d10_6[7] + 2 * d10_7[0] + 4 * d10_7[1] + 8 * d10_7[2] + 16 * d10_7[3] + 32 * d10_7[4] + 64 * d10_7[5] + 128 * d10_7[6])
-      ];
-      -- b20 = rotl(t2, 62) = byte-rotl 7 + bit-shl 6
-      let d20_0 = u8_bit_decomposition(t2[0]);
-      let d20_1 = u8_bit_decomposition(t2[1]);
-      let d20_2 = u8_bit_decomposition(t2[2]);
-      let d20_3 = u8_bit_decomposition(t2[3]);
-      let d20_4 = u8_bit_decomposition(t2[4]);
-      let d20_5 = u8_bit_decomposition(t2[5]);
-      let d20_6 = u8_bit_decomposition(t2[6]);
-      let d20_7 = u8_bit_decomposition(t2[7]);
-      let b20 = [
-        u8_from_field_unsafe(d20_0[2] + 2 * d20_0[3] + 4 * d20_0[4] + 8 * d20_0[5] + 16 * d20_0[6] + 32 * d20_0[7] + 64 * d20_1[0] + 128 * d20_1[1]),
-        u8_from_field_unsafe(d20_1[2] + 2 * d20_1[3] + 4 * d20_1[4] + 8 * d20_1[5] + 16 * d20_1[6] + 32 * d20_1[7] + 64 * d20_2[0] + 128 * d20_2[1]),
-        u8_from_field_unsafe(d20_2[2] + 2 * d20_2[3] + 4 * d20_2[4] + 8 * d20_2[5] + 16 * d20_2[6] + 32 * d20_2[7] + 64 * d20_3[0] + 128 * d20_3[1]),
-        u8_from_field_unsafe(d20_3[2] + 2 * d20_3[3] + 4 * d20_3[4] + 8 * d20_3[5] + 16 * d20_3[6] + 32 * d20_3[7] + 64 * d20_4[0] + 128 * d20_4[1]),
-        u8_from_field_unsafe(d20_4[2] + 2 * d20_4[3] + 4 * d20_4[4] + 8 * d20_4[5] + 16 * d20_4[6] + 32 * d20_4[7] + 64 * d20_5[0] + 128 * d20_5[1]),
-        u8_from_field_unsafe(d20_5[2] + 2 * d20_5[3] + 4 * d20_5[4] + 8 * d20_5[5] + 16 * d20_5[6] + 32 * d20_5[7] + 64 * d20_6[0] + 128 * d20_6[1]),
-        u8_from_field_unsafe(d20_6[2] + 2 * d20_6[3] + 4 * d20_6[4] + 8 * d20_6[5] + 16 * d20_6[6] + 32 * d20_6[7] + 64 * d20_7[0] + 128 * d20_7[1]),
-        u8_from_field_unsafe(d20_7[2] + 2 * d20_7[3] + 4 * d20_7[4] + 8 * d20_7[5] + 16 * d20_7[6] + 32 * d20_7[7] + 64 * d20_0[0] + 128 * d20_0[1])
-      ];
-      -- b5 = rotl(t3, 28) = byte-rotl 3 + bit-shl 4
+      -- b10 = rotl(t1, 1) = byte-rotl 0 + 1x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a10_0_0, c10_0_0) = u8_add(t1[0], t1[0]);
+      let (a10_0_1, c10_0_1) = u8_add(t1[1], t1[1]);
+      let (a10_0_2, c10_0_2) = u8_add(t1[2], t1[2]);
+      let (a10_0_3, c10_0_3) = u8_add(t1[3], t1[3]);
+      let (a10_0_4, c10_0_4) = u8_add(t1[4], t1[4]);
+      let (a10_0_5, c10_0_5) = u8_add(t1[5], t1[5]);
+      let (a10_0_6, c10_0_6) = u8_add(t1[6], t1[6]);
+      let (a10_0_7, c10_0_7) = u8_add(t1[7], t1[7]);
+      let b10 = [u8_from_field_unsafe(to_field(a10_0_0) + to_field(c10_0_7)), u8_from_field_unsafe(to_field(a10_0_1) + to_field(c10_0_0)), u8_from_field_unsafe(to_field(a10_0_2) + to_field(c10_0_1)), u8_from_field_unsafe(to_field(a10_0_3) + to_field(c10_0_2)), u8_from_field_unsafe(to_field(a10_0_4) + to_field(c10_0_3)), u8_from_field_unsafe(to_field(a10_0_5) + to_field(c10_0_4)), u8_from_field_unsafe(to_field(a10_0_6) + to_field(c10_0_5)), u8_from_field_unsafe(to_field(a10_0_7) + to_field(c10_0_6))];
+      -- b20 = rotl(t2, 62) = byte-rotl 8 + 2x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h20_0_0 = u8_shift_right(t2[0]);
+      let h20_0_1 = u8_shift_right(t2[1]);
+      let h20_0_2 = u8_shift_right(t2[2]);
+      let h20_0_3 = u8_shift_right(t2[3]);
+      let h20_0_4 = u8_shift_right(t2[4]);
+      let h20_0_5 = u8_shift_right(t2[5]);
+      let h20_0_6 = u8_shift_right(t2[6]);
+      let h20_0_7 = u8_shift_right(t2[7]);
+      let h20_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0) + 128 * (to_field(t2[1]) - 2 * to_field(h20_0_1))));
+      let h20_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_1) + 128 * (to_field(t2[2]) - 2 * to_field(h20_0_2))));
+      let h20_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_2) + 128 * (to_field(t2[3]) - 2 * to_field(h20_0_3))));
+      let h20_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_3) + 128 * (to_field(t2[4]) - 2 * to_field(h20_0_4))));
+      let h20_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_4) + 128 * (to_field(t2[5]) - 2 * to_field(h20_0_5))));
+      let h20_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_5) + 128 * (to_field(t2[6]) - 2 * to_field(h20_0_6))));
+      let h20_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_6) + 128 * (to_field(t2[7]) - 2 * to_field(h20_0_7))));
+      let h20_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_7) + 128 * (to_field(t2[0]) - 2 * to_field(h20_0_0))));
+      let b20 = [u8_from_field_unsafe(to_field(h20_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_1) + 128 * (to_field(t2[2]) - 2 * to_field(h20_0_2)))) - 2 * to_field(h20_1_1))), u8_from_field_unsafe(to_field(h20_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_2) + 128 * (to_field(t2[3]) - 2 * to_field(h20_0_3)))) - 2 * to_field(h20_1_2))), u8_from_field_unsafe(to_field(h20_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_3) + 128 * (to_field(t2[4]) - 2 * to_field(h20_0_4)))) - 2 * to_field(h20_1_3))), u8_from_field_unsafe(to_field(h20_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_4) + 128 * (to_field(t2[5]) - 2 * to_field(h20_0_5)))) - 2 * to_field(h20_1_4))), u8_from_field_unsafe(to_field(h20_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_5) + 128 * (to_field(t2[6]) - 2 * to_field(h20_0_6)))) - 2 * to_field(h20_1_5))), u8_from_field_unsafe(to_field(h20_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_6) + 128 * (to_field(t2[7]) - 2 * to_field(h20_0_7)))) - 2 * to_field(h20_1_6))), u8_from_field_unsafe(to_field(h20_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_7) + 128 * (to_field(t2[0]) - 2 * to_field(h20_0_0)))) - 2 * to_field(h20_1_7))), u8_from_field_unsafe(to_field(h20_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0) + 128 * (to_field(t2[1]) - 2 * to_field(h20_0_1)))) - 2 * to_field(h20_1_0)))];
+      -- b5 = rotl(t3, 28) = byte-rotl 3 + bit-shl 4 (decomposition)
       let d5_0 = u8_bit_decomposition(t3[0]);
       let d5_1 = u8_bit_decomposition(t3[1]);
       let d5_2 = u8_bit_decomposition(t3[2]);
@@ -396,36 +386,34 @@ def keccak := ⟦
       let d5_5 = u8_bit_decomposition(t3[5]);
       let d5_6 = u8_bit_decomposition(t3[6]);
       let d5_7 = u8_bit_decomposition(t3[7]);
-      let b5 = [
-        u8_from_field_unsafe(d5_4[4] + 2 * d5_4[5] + 4 * d5_4[6] + 8 * d5_4[7] + 16 * d5_5[0] + 32 * d5_5[1] + 64 * d5_5[2] + 128 * d5_5[3]),
-        u8_from_field_unsafe(d5_5[4] + 2 * d5_5[5] + 4 * d5_5[6] + 8 * d5_5[7] + 16 * d5_6[0] + 32 * d5_6[1] + 64 * d5_6[2] + 128 * d5_6[3]),
-        u8_from_field_unsafe(d5_6[4] + 2 * d5_6[5] + 4 * d5_6[6] + 8 * d5_6[7] + 16 * d5_7[0] + 32 * d5_7[1] + 64 * d5_7[2] + 128 * d5_7[3]),
-        u8_from_field_unsafe(d5_7[4] + 2 * d5_7[5] + 4 * d5_7[6] + 8 * d5_7[7] + 16 * d5_0[0] + 32 * d5_0[1] + 64 * d5_0[2] + 128 * d5_0[3]),
-        u8_from_field_unsafe(d5_0[4] + 2 * d5_0[5] + 4 * d5_0[6] + 8 * d5_0[7] + 16 * d5_1[0] + 32 * d5_1[1] + 64 * d5_1[2] + 128 * d5_1[3]),
-        u8_from_field_unsafe(d5_1[4] + 2 * d5_1[5] + 4 * d5_1[6] + 8 * d5_1[7] + 16 * d5_2[0] + 32 * d5_2[1] + 64 * d5_2[2] + 128 * d5_2[3]),
-        u8_from_field_unsafe(d5_2[4] + 2 * d5_2[5] + 4 * d5_2[6] + 8 * d5_2[7] + 16 * d5_3[0] + 32 * d5_3[1] + 64 * d5_3[2] + 128 * d5_3[3]),
-        u8_from_field_unsafe(d5_3[4] + 2 * d5_3[5] + 4 * d5_3[6] + 8 * d5_3[7] + 16 * d5_4[0] + 32 * d5_4[1] + 64 * d5_4[2] + 128 * d5_4[3])
-      ];
-      -- b15 = rotl(t4, 27) = byte-rotl 3 + bit-shl 3
-      let d15_0 = u8_bit_decomposition(t4[0]);
-      let d15_1 = u8_bit_decomposition(t4[1]);
-      let d15_2 = u8_bit_decomposition(t4[2]);
-      let d15_3 = u8_bit_decomposition(t4[3]);
-      let d15_4 = u8_bit_decomposition(t4[4]);
-      let d15_5 = u8_bit_decomposition(t4[5]);
-      let d15_6 = u8_bit_decomposition(t4[6]);
-      let d15_7 = u8_bit_decomposition(t4[7]);
-      let b15 = [
-        u8_from_field_unsafe(d15_4[5] + 2 * d15_4[6] + 4 * d15_4[7] + 8 * d15_5[0] + 16 * d15_5[1] + 32 * d15_5[2] + 64 * d15_5[3] + 128 * d15_5[4]),
-        u8_from_field_unsafe(d15_5[5] + 2 * d15_5[6] + 4 * d15_5[7] + 8 * d15_6[0] + 16 * d15_6[1] + 32 * d15_6[2] + 64 * d15_6[3] + 128 * d15_6[4]),
-        u8_from_field_unsafe(d15_6[5] + 2 * d15_6[6] + 4 * d15_6[7] + 8 * d15_7[0] + 16 * d15_7[1] + 32 * d15_7[2] + 64 * d15_7[3] + 128 * d15_7[4]),
-        u8_from_field_unsafe(d15_7[5] + 2 * d15_7[6] + 4 * d15_7[7] + 8 * d15_0[0] + 16 * d15_0[1] + 32 * d15_0[2] + 64 * d15_0[3] + 128 * d15_0[4]),
-        u8_from_field_unsafe(d15_0[5] + 2 * d15_0[6] + 4 * d15_0[7] + 8 * d15_1[0] + 16 * d15_1[1] + 32 * d15_1[2] + 64 * d15_1[3] + 128 * d15_1[4]),
-        u8_from_field_unsafe(d15_1[5] + 2 * d15_1[6] + 4 * d15_1[7] + 8 * d15_2[0] + 16 * d15_2[1] + 32 * d15_2[2] + 64 * d15_2[3] + 128 * d15_2[4]),
-        u8_from_field_unsafe(d15_2[5] + 2 * d15_2[6] + 4 * d15_2[7] + 8 * d15_3[0] + 16 * d15_3[1] + 32 * d15_3[2] + 64 * d15_3[3] + 128 * d15_3[4]),
-        u8_from_field_unsafe(d15_3[5] + 2 * d15_3[6] + 4 * d15_3[7] + 8 * d15_4[0] + 16 * d15_4[1] + 32 * d15_4[2] + 64 * d15_4[3] + 128 * d15_4[4])
-      ];
-      -- b16 = rotl(t5, 36) = byte-rotl 4 + bit-shl 4
+      let b5 = [u8_from_field_unsafe(d5_4[4] + 2 * d5_4[5] + 4 * d5_4[6] + 8 * d5_4[7] + 16 * d5_5[0] + 32 * d5_5[1] + 64 * d5_5[2] + 128 * d5_5[3]), u8_from_field_unsafe(d5_5[4] + 2 * d5_5[5] + 4 * d5_5[6] + 8 * d5_5[7] + 16 * d5_6[0] + 32 * d5_6[1] + 64 * d5_6[2] + 128 * d5_6[3]), u8_from_field_unsafe(d5_6[4] + 2 * d5_6[5] + 4 * d5_6[6] + 8 * d5_6[7] + 16 * d5_7[0] + 32 * d5_7[1] + 64 * d5_7[2] + 128 * d5_7[3]), u8_from_field_unsafe(d5_7[4] + 2 * d5_7[5] + 4 * d5_7[6] + 8 * d5_7[7] + 16 * d5_0[0] + 32 * d5_0[1] + 64 * d5_0[2] + 128 * d5_0[3]), u8_from_field_unsafe(d5_0[4] + 2 * d5_0[5] + 4 * d5_0[6] + 8 * d5_0[7] + 16 * d5_1[0] + 32 * d5_1[1] + 64 * d5_1[2] + 128 * d5_1[3]), u8_from_field_unsafe(d5_1[4] + 2 * d5_1[5] + 4 * d5_1[6] + 8 * d5_1[7] + 16 * d5_2[0] + 32 * d5_2[1] + 64 * d5_2[2] + 128 * d5_2[3]), u8_from_field_unsafe(d5_2[4] + 2 * d5_2[5] + 4 * d5_2[6] + 8 * d5_2[7] + 16 * d5_3[0] + 32 * d5_3[1] + 64 * d5_3[2] + 128 * d5_3[3]), u8_from_field_unsafe(d5_3[4] + 2 * d5_3[5] + 4 * d5_3[6] + 8 * d5_3[7] + 16 * d5_4[0] + 32 * d5_4[1] + 64 * d5_4[2] + 128 * d5_4[3])];
+      -- b15 = rotl(t4, 27) = byte-rotl 3 + 3x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a15_0_0, c15_0_0) = u8_add(t4[5], t4[5]);
+      let (a15_0_1, c15_0_1) = u8_add(t4[6], t4[6]);
+      let (a15_0_2, c15_0_2) = u8_add(t4[7], t4[7]);
+      let (a15_0_3, c15_0_3) = u8_add(t4[0], t4[0]);
+      let (a15_0_4, c15_0_4) = u8_add(t4[1], t4[1]);
+      let (a15_0_5, c15_0_5) = u8_add(t4[2], t4[2]);
+      let (a15_0_6, c15_0_6) = u8_add(t4[3], t4[3]);
+      let (a15_0_7, c15_0_7) = u8_add(t4[4], t4[4]);
+      let (a15_1_0, c15_1_0) = u8_add(u8_from_field_unsafe(to_field(a15_0_0) + to_field(c15_0_7)), u8_from_field_unsafe(to_field(a15_0_0) + to_field(c15_0_7)));
+      let (a15_1_1, c15_1_1) = u8_add(u8_from_field_unsafe(to_field(a15_0_1) + to_field(c15_0_0)), u8_from_field_unsafe(to_field(a15_0_1) + to_field(c15_0_0)));
+      let (a15_1_2, c15_1_2) = u8_add(u8_from_field_unsafe(to_field(a15_0_2) + to_field(c15_0_1)), u8_from_field_unsafe(to_field(a15_0_2) + to_field(c15_0_1)));
+      let (a15_1_3, c15_1_3) = u8_add(u8_from_field_unsafe(to_field(a15_0_3) + to_field(c15_0_2)), u8_from_field_unsafe(to_field(a15_0_3) + to_field(c15_0_2)));
+      let (a15_1_4, c15_1_4) = u8_add(u8_from_field_unsafe(to_field(a15_0_4) + to_field(c15_0_3)), u8_from_field_unsafe(to_field(a15_0_4) + to_field(c15_0_3)));
+      let (a15_1_5, c15_1_5) = u8_add(u8_from_field_unsafe(to_field(a15_0_5) + to_field(c15_0_4)), u8_from_field_unsafe(to_field(a15_0_5) + to_field(c15_0_4)));
+      let (a15_1_6, c15_1_6) = u8_add(u8_from_field_unsafe(to_field(a15_0_6) + to_field(c15_0_5)), u8_from_field_unsafe(to_field(a15_0_6) + to_field(c15_0_5)));
+      let (a15_1_7, c15_1_7) = u8_add(u8_from_field_unsafe(to_field(a15_0_7) + to_field(c15_0_6)), u8_from_field_unsafe(to_field(a15_0_7) + to_field(c15_0_6)));
+      let (a15_2_0, c15_2_0) = u8_add(u8_from_field_unsafe(to_field(a15_1_0) + to_field(c15_1_7)), u8_from_field_unsafe(to_field(a15_1_0) + to_field(c15_1_7)));
+      let (a15_2_1, c15_2_1) = u8_add(u8_from_field_unsafe(to_field(a15_1_1) + to_field(c15_1_0)), u8_from_field_unsafe(to_field(a15_1_1) + to_field(c15_1_0)));
+      let (a15_2_2, c15_2_2) = u8_add(u8_from_field_unsafe(to_field(a15_1_2) + to_field(c15_1_1)), u8_from_field_unsafe(to_field(a15_1_2) + to_field(c15_1_1)));
+      let (a15_2_3, c15_2_3) = u8_add(u8_from_field_unsafe(to_field(a15_1_3) + to_field(c15_1_2)), u8_from_field_unsafe(to_field(a15_1_3) + to_field(c15_1_2)));
+      let (a15_2_4, c15_2_4) = u8_add(u8_from_field_unsafe(to_field(a15_1_4) + to_field(c15_1_3)), u8_from_field_unsafe(to_field(a15_1_4) + to_field(c15_1_3)));
+      let (a15_2_5, c15_2_5) = u8_add(u8_from_field_unsafe(to_field(a15_1_5) + to_field(c15_1_4)), u8_from_field_unsafe(to_field(a15_1_5) + to_field(c15_1_4)));
+      let (a15_2_6, c15_2_6) = u8_add(u8_from_field_unsafe(to_field(a15_1_6) + to_field(c15_1_5)), u8_from_field_unsafe(to_field(a15_1_6) + to_field(c15_1_5)));
+      let (a15_2_7, c15_2_7) = u8_add(u8_from_field_unsafe(to_field(a15_1_7) + to_field(c15_1_6)), u8_from_field_unsafe(to_field(a15_1_7) + to_field(c15_1_6)));
+      let b15 = [u8_from_field_unsafe(to_field(a15_2_0) + to_field(c15_2_7)), u8_from_field_unsafe(to_field(a15_2_1) + to_field(c15_2_0)), u8_from_field_unsafe(to_field(a15_2_2) + to_field(c15_2_1)), u8_from_field_unsafe(to_field(a15_2_3) + to_field(c15_2_2)), u8_from_field_unsafe(to_field(a15_2_4) + to_field(c15_2_3)), u8_from_field_unsafe(to_field(a15_2_5) + to_field(c15_2_4)), u8_from_field_unsafe(to_field(a15_2_6) + to_field(c15_2_5)), u8_from_field_unsafe(to_field(a15_2_7) + to_field(c15_2_6))];
+      -- b16 = rotl(t5, 36) = byte-rotl 4 + bit-shl 4 (decomposition)
       let d16_0 = u8_bit_decomposition(t5[0]);
       let d16_1 = u8_bit_decomposition(t5[1]);
       let d16_2 = u8_bit_decomposition(t5[2]);
@@ -434,17 +422,8 @@ def keccak := ⟦
       let d16_5 = u8_bit_decomposition(t5[5]);
       let d16_6 = u8_bit_decomposition(t5[6]);
       let d16_7 = u8_bit_decomposition(t5[7]);
-      let b16 = [
-        u8_from_field_unsafe(d16_3[4] + 2 * d16_3[5] + 4 * d16_3[6] + 8 * d16_3[7] + 16 * d16_4[0] + 32 * d16_4[1] + 64 * d16_4[2] + 128 * d16_4[3]),
-        u8_from_field_unsafe(d16_4[4] + 2 * d16_4[5] + 4 * d16_4[6] + 8 * d16_4[7] + 16 * d16_5[0] + 32 * d16_5[1] + 64 * d16_5[2] + 128 * d16_5[3]),
-        u8_from_field_unsafe(d16_5[4] + 2 * d16_5[5] + 4 * d16_5[6] + 8 * d16_5[7] + 16 * d16_6[0] + 32 * d16_6[1] + 64 * d16_6[2] + 128 * d16_6[3]),
-        u8_from_field_unsafe(d16_6[4] + 2 * d16_6[5] + 4 * d16_6[6] + 8 * d16_6[7] + 16 * d16_7[0] + 32 * d16_7[1] + 64 * d16_7[2] + 128 * d16_7[3]),
-        u8_from_field_unsafe(d16_7[4] + 2 * d16_7[5] + 4 * d16_7[6] + 8 * d16_7[7] + 16 * d16_0[0] + 32 * d16_0[1] + 64 * d16_0[2] + 128 * d16_0[3]),
-        u8_from_field_unsafe(d16_0[4] + 2 * d16_0[5] + 4 * d16_0[6] + 8 * d16_0[7] + 16 * d16_1[0] + 32 * d16_1[1] + 64 * d16_1[2] + 128 * d16_1[3]),
-        u8_from_field_unsafe(d16_1[4] + 2 * d16_1[5] + 4 * d16_1[6] + 8 * d16_1[7] + 16 * d16_2[0] + 32 * d16_2[1] + 64 * d16_2[2] + 128 * d16_2[3]),
-        u8_from_field_unsafe(d16_2[4] + 2 * d16_2[5] + 4 * d16_2[6] + 8 * d16_2[7] + 16 * d16_3[0] + 32 * d16_3[1] + 64 * d16_3[2] + 128 * d16_3[3])
-      ];
-      -- b1 = rotl(t6, 44) = byte-rotl 5 + bit-shl 4
+      let b16 = [u8_from_field_unsafe(d16_3[4] + 2 * d16_3[5] + 4 * d16_3[6] + 8 * d16_3[7] + 16 * d16_4[0] + 32 * d16_4[1] + 64 * d16_4[2] + 128 * d16_4[3]), u8_from_field_unsafe(d16_4[4] + 2 * d16_4[5] + 4 * d16_4[6] + 8 * d16_4[7] + 16 * d16_5[0] + 32 * d16_5[1] + 64 * d16_5[2] + 128 * d16_5[3]), u8_from_field_unsafe(d16_5[4] + 2 * d16_5[5] + 4 * d16_5[6] + 8 * d16_5[7] + 16 * d16_6[0] + 32 * d16_6[1] + 64 * d16_6[2] + 128 * d16_6[3]), u8_from_field_unsafe(d16_6[4] + 2 * d16_6[5] + 4 * d16_6[6] + 8 * d16_6[7] + 16 * d16_7[0] + 32 * d16_7[1] + 64 * d16_7[2] + 128 * d16_7[3]), u8_from_field_unsafe(d16_7[4] + 2 * d16_7[5] + 4 * d16_7[6] + 8 * d16_7[7] + 16 * d16_0[0] + 32 * d16_0[1] + 64 * d16_0[2] + 128 * d16_0[3]), u8_from_field_unsafe(d16_0[4] + 2 * d16_0[5] + 4 * d16_0[6] + 8 * d16_0[7] + 16 * d16_1[0] + 32 * d16_1[1] + 64 * d16_1[2] + 128 * d16_1[3]), u8_from_field_unsafe(d16_1[4] + 2 * d16_1[5] + 4 * d16_1[6] + 8 * d16_1[7] + 16 * d16_2[0] + 32 * d16_2[1] + 64 * d16_2[2] + 128 * d16_2[3]), u8_from_field_unsafe(d16_2[4] + 2 * d16_2[5] + 4 * d16_2[6] + 8 * d16_2[7] + 16 * d16_3[0] + 32 * d16_3[1] + 64 * d16_3[2] + 128 * d16_3[3])];
+      -- b1 = rotl(t6, 44) = byte-rotl 5 + bit-shl 4 (decomposition)
       let d1_0 = u8_bit_decomposition(t6[0]);
       let d1_1 = u8_bit_decomposition(t6[1]);
       let d1_2 = u8_bit_decomposition(t6[2]);
@@ -453,55 +432,36 @@ def keccak := ⟦
       let d1_5 = u8_bit_decomposition(t6[5]);
       let d1_6 = u8_bit_decomposition(t6[6]);
       let d1_7 = u8_bit_decomposition(t6[7]);
-      let b1 = [
-        u8_from_field_unsafe(d1_2[4] + 2 * d1_2[5] + 4 * d1_2[6] + 8 * d1_2[7] + 16 * d1_3[0] + 32 * d1_3[1] + 64 * d1_3[2] + 128 * d1_3[3]),
-        u8_from_field_unsafe(d1_3[4] + 2 * d1_3[5] + 4 * d1_3[6] + 8 * d1_3[7] + 16 * d1_4[0] + 32 * d1_4[1] + 64 * d1_4[2] + 128 * d1_4[3]),
-        u8_from_field_unsafe(d1_4[4] + 2 * d1_4[5] + 4 * d1_4[6] + 8 * d1_4[7] + 16 * d1_5[0] + 32 * d1_5[1] + 64 * d1_5[2] + 128 * d1_5[3]),
-        u8_from_field_unsafe(d1_5[4] + 2 * d1_5[5] + 4 * d1_5[6] + 8 * d1_5[7] + 16 * d1_6[0] + 32 * d1_6[1] + 64 * d1_6[2] + 128 * d1_6[3]),
-        u8_from_field_unsafe(d1_6[4] + 2 * d1_6[5] + 4 * d1_6[6] + 8 * d1_6[7] + 16 * d1_7[0] + 32 * d1_7[1] + 64 * d1_7[2] + 128 * d1_7[3]),
-        u8_from_field_unsafe(d1_7[4] + 2 * d1_7[5] + 4 * d1_7[6] + 8 * d1_7[7] + 16 * d1_0[0] + 32 * d1_0[1] + 64 * d1_0[2] + 128 * d1_0[3]),
-        u8_from_field_unsafe(d1_0[4] + 2 * d1_0[5] + 4 * d1_0[6] + 8 * d1_0[7] + 16 * d1_1[0] + 32 * d1_1[1] + 64 * d1_1[2] + 128 * d1_1[3]),
-        u8_from_field_unsafe(d1_1[4] + 2 * d1_1[5] + 4 * d1_1[6] + 8 * d1_1[7] + 16 * d1_2[0] + 32 * d1_2[1] + 64 * d1_2[2] + 128 * d1_2[3])
-      ];
-      -- b11 = rotl(t7, 6) = byte-rotl 0 + bit-shl 6
-      let d11_0 = u8_bit_decomposition(t7[0]);
-      let d11_1 = u8_bit_decomposition(t7[1]);
-      let d11_2 = u8_bit_decomposition(t7[2]);
-      let d11_3 = u8_bit_decomposition(t7[3]);
-      let d11_4 = u8_bit_decomposition(t7[4]);
-      let d11_5 = u8_bit_decomposition(t7[5]);
-      let d11_6 = u8_bit_decomposition(t7[6]);
-      let d11_7 = u8_bit_decomposition(t7[7]);
-      let b11 = [
-        u8_from_field_unsafe(d11_7[2] + 2 * d11_7[3] + 4 * d11_7[4] + 8 * d11_7[5] + 16 * d11_7[6] + 32 * d11_7[7] + 64 * d11_0[0] + 128 * d11_0[1]),
-        u8_from_field_unsafe(d11_0[2] + 2 * d11_0[3] + 4 * d11_0[4] + 8 * d11_0[5] + 16 * d11_0[6] + 32 * d11_0[7] + 64 * d11_1[0] + 128 * d11_1[1]),
-        u8_from_field_unsafe(d11_1[2] + 2 * d11_1[3] + 4 * d11_1[4] + 8 * d11_1[5] + 16 * d11_1[6] + 32 * d11_1[7] + 64 * d11_2[0] + 128 * d11_2[1]),
-        u8_from_field_unsafe(d11_2[2] + 2 * d11_2[3] + 4 * d11_2[4] + 8 * d11_2[5] + 16 * d11_2[6] + 32 * d11_2[7] + 64 * d11_3[0] + 128 * d11_3[1]),
-        u8_from_field_unsafe(d11_3[2] + 2 * d11_3[3] + 4 * d11_3[4] + 8 * d11_3[5] + 16 * d11_3[6] + 32 * d11_3[7] + 64 * d11_4[0] + 128 * d11_4[1]),
-        u8_from_field_unsafe(d11_4[2] + 2 * d11_4[3] + 4 * d11_4[4] + 8 * d11_4[5] + 16 * d11_4[6] + 32 * d11_4[7] + 64 * d11_5[0] + 128 * d11_5[1]),
-        u8_from_field_unsafe(d11_5[2] + 2 * d11_5[3] + 4 * d11_5[4] + 8 * d11_5[5] + 16 * d11_5[6] + 32 * d11_5[7] + 64 * d11_6[0] + 128 * d11_6[1]),
-        u8_from_field_unsafe(d11_6[2] + 2 * d11_6[3] + 4 * d11_6[4] + 8 * d11_6[5] + 16 * d11_6[6] + 32 * d11_6[7] + 64 * d11_7[0] + 128 * d11_7[1])
-      ];
-      -- b21 = rotl(t8, 55) = byte-rotl 6 + bit-shl 7
-      let d21_0 = u8_bit_decomposition(t8[0]);
-      let d21_1 = u8_bit_decomposition(t8[1]);
-      let d21_2 = u8_bit_decomposition(t8[2]);
-      let d21_3 = u8_bit_decomposition(t8[3]);
-      let d21_4 = u8_bit_decomposition(t8[4]);
-      let d21_5 = u8_bit_decomposition(t8[5]);
-      let d21_6 = u8_bit_decomposition(t8[6]);
-      let d21_7 = u8_bit_decomposition(t8[7]);
-      let b21 = [
-        u8_from_field_unsafe(d21_1[1] + 2 * d21_1[2] + 4 * d21_1[3] + 8 * d21_1[4] + 16 * d21_1[5] + 32 * d21_1[6] + 64 * d21_1[7] + 128 * d21_2[0]),
-        u8_from_field_unsafe(d21_2[1] + 2 * d21_2[2] + 4 * d21_2[3] + 8 * d21_2[4] + 16 * d21_2[5] + 32 * d21_2[6] + 64 * d21_2[7] + 128 * d21_3[0]),
-        u8_from_field_unsafe(d21_3[1] + 2 * d21_3[2] + 4 * d21_3[3] + 8 * d21_3[4] + 16 * d21_3[5] + 32 * d21_3[6] + 64 * d21_3[7] + 128 * d21_4[0]),
-        u8_from_field_unsafe(d21_4[1] + 2 * d21_4[2] + 4 * d21_4[3] + 8 * d21_4[4] + 16 * d21_4[5] + 32 * d21_4[6] + 64 * d21_4[7] + 128 * d21_5[0]),
-        u8_from_field_unsafe(d21_5[1] + 2 * d21_5[2] + 4 * d21_5[3] + 8 * d21_5[4] + 16 * d21_5[5] + 32 * d21_5[6] + 64 * d21_5[7] + 128 * d21_6[0]),
-        u8_from_field_unsafe(d21_6[1] + 2 * d21_6[2] + 4 * d21_6[3] + 8 * d21_6[4] + 16 * d21_6[5] + 32 * d21_6[6] + 64 * d21_6[7] + 128 * d21_7[0]),
-        u8_from_field_unsafe(d21_7[1] + 2 * d21_7[2] + 4 * d21_7[3] + 8 * d21_7[4] + 16 * d21_7[5] + 32 * d21_7[6] + 64 * d21_7[7] + 128 * d21_0[0]),
-        u8_from_field_unsafe(d21_0[1] + 2 * d21_0[2] + 4 * d21_0[3] + 8 * d21_0[4] + 16 * d21_0[5] + 32 * d21_0[6] + 64 * d21_0[7] + 128 * d21_1[0])
-      ];
-      -- b6 = rotl(t9, 20) = byte-rotl 2 + bit-shl 4
+      let b1 = [u8_from_field_unsafe(d1_2[4] + 2 * d1_2[5] + 4 * d1_2[6] + 8 * d1_2[7] + 16 * d1_3[0] + 32 * d1_3[1] + 64 * d1_3[2] + 128 * d1_3[3]), u8_from_field_unsafe(d1_3[4] + 2 * d1_3[5] + 4 * d1_3[6] + 8 * d1_3[7] + 16 * d1_4[0] + 32 * d1_4[1] + 64 * d1_4[2] + 128 * d1_4[3]), u8_from_field_unsafe(d1_4[4] + 2 * d1_4[5] + 4 * d1_4[6] + 8 * d1_4[7] + 16 * d1_5[0] + 32 * d1_5[1] + 64 * d1_5[2] + 128 * d1_5[3]), u8_from_field_unsafe(d1_5[4] + 2 * d1_5[5] + 4 * d1_5[6] + 8 * d1_5[7] + 16 * d1_6[0] + 32 * d1_6[1] + 64 * d1_6[2] + 128 * d1_6[3]), u8_from_field_unsafe(d1_6[4] + 2 * d1_6[5] + 4 * d1_6[6] + 8 * d1_6[7] + 16 * d1_7[0] + 32 * d1_7[1] + 64 * d1_7[2] + 128 * d1_7[3]), u8_from_field_unsafe(d1_7[4] + 2 * d1_7[5] + 4 * d1_7[6] + 8 * d1_7[7] + 16 * d1_0[0] + 32 * d1_0[1] + 64 * d1_0[2] + 128 * d1_0[3]), u8_from_field_unsafe(d1_0[4] + 2 * d1_0[5] + 4 * d1_0[6] + 8 * d1_0[7] + 16 * d1_1[0] + 32 * d1_1[1] + 64 * d1_1[2] + 128 * d1_1[3]), u8_from_field_unsafe(d1_1[4] + 2 * d1_1[5] + 4 * d1_1[6] + 8 * d1_1[7] + 16 * d1_2[0] + 32 * d1_2[1] + 64 * d1_2[2] + 128 * d1_2[3])];
+      -- b11 = rotl(t7, 6) = byte-rotl 1 + 2x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h11_0_0 = u8_shift_right(t7[7]);
+      let h11_0_1 = u8_shift_right(t7[0]);
+      let h11_0_2 = u8_shift_right(t7[1]);
+      let h11_0_3 = u8_shift_right(t7[2]);
+      let h11_0_4 = u8_shift_right(t7[3]);
+      let h11_0_5 = u8_shift_right(t7[4]);
+      let h11_0_6 = u8_shift_right(t7[5]);
+      let h11_0_7 = u8_shift_right(t7[6]);
+      let h11_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0) + 128 * (to_field(t7[0]) - 2 * to_field(h11_0_1))));
+      let h11_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_1) + 128 * (to_field(t7[1]) - 2 * to_field(h11_0_2))));
+      let h11_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_2) + 128 * (to_field(t7[2]) - 2 * to_field(h11_0_3))));
+      let h11_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_3) + 128 * (to_field(t7[3]) - 2 * to_field(h11_0_4))));
+      let h11_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_4) + 128 * (to_field(t7[4]) - 2 * to_field(h11_0_5))));
+      let h11_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_5) + 128 * (to_field(t7[5]) - 2 * to_field(h11_0_6))));
+      let h11_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_6) + 128 * (to_field(t7[6]) - 2 * to_field(h11_0_7))));
+      let h11_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_7) + 128 * (to_field(t7[7]) - 2 * to_field(h11_0_0))));
+      let b11 = [u8_from_field_unsafe(to_field(h11_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_1) + 128 * (to_field(t7[1]) - 2 * to_field(h11_0_2)))) - 2 * to_field(h11_1_1))), u8_from_field_unsafe(to_field(h11_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_2) + 128 * (to_field(t7[2]) - 2 * to_field(h11_0_3)))) - 2 * to_field(h11_1_2))), u8_from_field_unsafe(to_field(h11_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_3) + 128 * (to_field(t7[3]) - 2 * to_field(h11_0_4)))) - 2 * to_field(h11_1_3))), u8_from_field_unsafe(to_field(h11_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_4) + 128 * (to_field(t7[4]) - 2 * to_field(h11_0_5)))) - 2 * to_field(h11_1_4))), u8_from_field_unsafe(to_field(h11_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_5) + 128 * (to_field(t7[5]) - 2 * to_field(h11_0_6)))) - 2 * to_field(h11_1_5))), u8_from_field_unsafe(to_field(h11_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_6) + 128 * (to_field(t7[6]) - 2 * to_field(h11_0_7)))) - 2 * to_field(h11_1_6))), u8_from_field_unsafe(to_field(h11_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_7) + 128 * (to_field(t7[7]) - 2 * to_field(h11_0_0)))) - 2 * to_field(h11_1_7))), u8_from_field_unsafe(to_field(h11_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0) + 128 * (to_field(t7[0]) - 2 * to_field(h11_0_1)))) - 2 * to_field(h11_1_0)))];
+      -- b21 = rotl(t8, 55) = byte-rotl 7 + 1x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h21_0_0 = u8_shift_right(t8[1]);
+      let h21_0_1 = u8_shift_right(t8[2]);
+      let h21_0_2 = u8_shift_right(t8[3]);
+      let h21_0_3 = u8_shift_right(t8[4]);
+      let h21_0_4 = u8_shift_right(t8[5]);
+      let h21_0_5 = u8_shift_right(t8[6]);
+      let h21_0_6 = u8_shift_right(t8[7]);
+      let h21_0_7 = u8_shift_right(t8[0]);
+      let b21 = [u8_from_field_unsafe(to_field(h21_0_0) + 128 * (to_field(t8[2]) - 2 * to_field(h21_0_1))), u8_from_field_unsafe(to_field(h21_0_1) + 128 * (to_field(t8[3]) - 2 * to_field(h21_0_2))), u8_from_field_unsafe(to_field(h21_0_2) + 128 * (to_field(t8[4]) - 2 * to_field(h21_0_3))), u8_from_field_unsafe(to_field(h21_0_3) + 128 * (to_field(t8[5]) - 2 * to_field(h21_0_4))), u8_from_field_unsafe(to_field(h21_0_4) + 128 * (to_field(t8[6]) - 2 * to_field(h21_0_5))), u8_from_field_unsafe(to_field(h21_0_5) + 128 * (to_field(t8[7]) - 2 * to_field(h21_0_6))), u8_from_field_unsafe(to_field(h21_0_6) + 128 * (to_field(t8[0]) - 2 * to_field(h21_0_7))), u8_from_field_unsafe(to_field(h21_0_7) + 128 * (to_field(t8[1]) - 2 * to_field(h21_0_0)))];
+      -- b6 = rotl(t9, 20) = byte-rotl 2 + bit-shl 4 (decomposition)
       let d6_0 = u8_bit_decomposition(t9[0]);
       let d6_1 = u8_bit_decomposition(t9[1]);
       let d6_2 = u8_bit_decomposition(t9[2]);
@@ -510,267 +470,253 @@ def keccak := ⟦
       let d6_5 = u8_bit_decomposition(t9[5]);
       let d6_6 = u8_bit_decomposition(t9[6]);
       let d6_7 = u8_bit_decomposition(t9[7]);
-      let b6 = [
-        u8_from_field_unsafe(d6_5[4] + 2 * d6_5[5] + 4 * d6_5[6] + 8 * d6_5[7] + 16 * d6_6[0] + 32 * d6_6[1] + 64 * d6_6[2] + 128 * d6_6[3]),
-        u8_from_field_unsafe(d6_6[4] + 2 * d6_6[5] + 4 * d6_6[6] + 8 * d6_6[7] + 16 * d6_7[0] + 32 * d6_7[1] + 64 * d6_7[2] + 128 * d6_7[3]),
-        u8_from_field_unsafe(d6_7[4] + 2 * d6_7[5] + 4 * d6_7[6] + 8 * d6_7[7] + 16 * d6_0[0] + 32 * d6_0[1] + 64 * d6_0[2] + 128 * d6_0[3]),
-        u8_from_field_unsafe(d6_0[4] + 2 * d6_0[5] + 4 * d6_0[6] + 8 * d6_0[7] + 16 * d6_1[0] + 32 * d6_1[1] + 64 * d6_1[2] + 128 * d6_1[3]),
-        u8_from_field_unsafe(d6_1[4] + 2 * d6_1[5] + 4 * d6_1[6] + 8 * d6_1[7] + 16 * d6_2[0] + 32 * d6_2[1] + 64 * d6_2[2] + 128 * d6_2[3]),
-        u8_from_field_unsafe(d6_2[4] + 2 * d6_2[5] + 4 * d6_2[6] + 8 * d6_2[7] + 16 * d6_3[0] + 32 * d6_3[1] + 64 * d6_3[2] + 128 * d6_3[3]),
-        u8_from_field_unsafe(d6_3[4] + 2 * d6_3[5] + 4 * d6_3[6] + 8 * d6_3[7] + 16 * d6_4[0] + 32 * d6_4[1] + 64 * d6_4[2] + 128 * d6_4[3]),
-        u8_from_field_unsafe(d6_4[4] + 2 * d6_4[5] + 4 * d6_4[6] + 8 * d6_4[7] + 16 * d6_5[0] + 32 * d6_5[1] + 64 * d6_5[2] + 128 * d6_5[3])
-      ];
-      -- b7 = rotl(t10, 3) = byte-rotl 0 + bit-shl 3
-      let d7_0 = u8_bit_decomposition(t10[0]);
-      let d7_1 = u8_bit_decomposition(t10[1]);
-      let d7_2 = u8_bit_decomposition(t10[2]);
-      let d7_3 = u8_bit_decomposition(t10[3]);
-      let d7_4 = u8_bit_decomposition(t10[4]);
-      let d7_5 = u8_bit_decomposition(t10[5]);
-      let d7_6 = u8_bit_decomposition(t10[6]);
-      let d7_7 = u8_bit_decomposition(t10[7]);
-      let b7 = [
-        u8_from_field_unsafe(d7_7[5] + 2 * d7_7[6] + 4 * d7_7[7] + 8 * d7_0[0] + 16 * d7_0[1] + 32 * d7_0[2] + 64 * d7_0[3] + 128 * d7_0[4]),
-        u8_from_field_unsafe(d7_0[5] + 2 * d7_0[6] + 4 * d7_0[7] + 8 * d7_1[0] + 16 * d7_1[1] + 32 * d7_1[2] + 64 * d7_1[3] + 128 * d7_1[4]),
-        u8_from_field_unsafe(d7_1[5] + 2 * d7_1[6] + 4 * d7_1[7] + 8 * d7_2[0] + 16 * d7_2[1] + 32 * d7_2[2] + 64 * d7_2[3] + 128 * d7_2[4]),
-        u8_from_field_unsafe(d7_2[5] + 2 * d7_2[6] + 4 * d7_2[7] + 8 * d7_3[0] + 16 * d7_3[1] + 32 * d7_3[2] + 64 * d7_3[3] + 128 * d7_3[4]),
-        u8_from_field_unsafe(d7_3[5] + 2 * d7_3[6] + 4 * d7_3[7] + 8 * d7_4[0] + 16 * d7_4[1] + 32 * d7_4[2] + 64 * d7_4[3] + 128 * d7_4[4]),
-        u8_from_field_unsafe(d7_4[5] + 2 * d7_4[6] + 4 * d7_4[7] + 8 * d7_5[0] + 16 * d7_5[1] + 32 * d7_5[2] + 64 * d7_5[3] + 128 * d7_5[4]),
-        u8_from_field_unsafe(d7_5[5] + 2 * d7_5[6] + 4 * d7_5[7] + 8 * d7_6[0] + 16 * d7_6[1] + 32 * d7_6[2] + 64 * d7_6[3] + 128 * d7_6[4]),
-        u8_from_field_unsafe(d7_6[5] + 2 * d7_6[6] + 4 * d7_6[7] + 8 * d7_7[0] + 16 * d7_7[1] + 32 * d7_7[2] + 64 * d7_7[3] + 128 * d7_7[4])
-      ];
-      -- b17 = rotl(t11, 10) = byte-rotl 1 + bit-shl 2
-      let d17_0 = u8_bit_decomposition(t11[0]);
-      let d17_1 = u8_bit_decomposition(t11[1]);
-      let d17_2 = u8_bit_decomposition(t11[2]);
-      let d17_3 = u8_bit_decomposition(t11[3]);
-      let d17_4 = u8_bit_decomposition(t11[4]);
-      let d17_5 = u8_bit_decomposition(t11[5]);
-      let d17_6 = u8_bit_decomposition(t11[6]);
-      let d17_7 = u8_bit_decomposition(t11[7]);
-      let b17 = [
-        u8_from_field_unsafe(d17_6[6] + 2 * d17_6[7] + 4 * d17_7[0] + 8 * d17_7[1] + 16 * d17_7[2] + 32 * d17_7[3] + 64 * d17_7[4] + 128 * d17_7[5]),
-        u8_from_field_unsafe(d17_7[6] + 2 * d17_7[7] + 4 * d17_0[0] + 8 * d17_0[1] + 16 * d17_0[2] + 32 * d17_0[3] + 64 * d17_0[4] + 128 * d17_0[5]),
-        u8_from_field_unsafe(d17_0[6] + 2 * d17_0[7] + 4 * d17_1[0] + 8 * d17_1[1] + 16 * d17_1[2] + 32 * d17_1[3] + 64 * d17_1[4] + 128 * d17_1[5]),
-        u8_from_field_unsafe(d17_1[6] + 2 * d17_1[7] + 4 * d17_2[0] + 8 * d17_2[1] + 16 * d17_2[2] + 32 * d17_2[3] + 64 * d17_2[4] + 128 * d17_2[5]),
-        u8_from_field_unsafe(d17_2[6] + 2 * d17_2[7] + 4 * d17_3[0] + 8 * d17_3[1] + 16 * d17_3[2] + 32 * d17_3[3] + 64 * d17_3[4] + 128 * d17_3[5]),
-        u8_from_field_unsafe(d17_3[6] + 2 * d17_3[7] + 4 * d17_4[0] + 8 * d17_4[1] + 16 * d17_4[2] + 32 * d17_4[3] + 64 * d17_4[4] + 128 * d17_4[5]),
-        u8_from_field_unsafe(d17_4[6] + 2 * d17_4[7] + 4 * d17_5[0] + 8 * d17_5[1] + 16 * d17_5[2] + 32 * d17_5[3] + 64 * d17_5[4] + 128 * d17_5[5]),
-        u8_from_field_unsafe(d17_5[6] + 2 * d17_5[7] + 4 * d17_6[0] + 8 * d17_6[1] + 16 * d17_6[2] + 32 * d17_6[3] + 64 * d17_6[4] + 128 * d17_6[5])
-      ];
-      -- b2 = rotl(t12, 43) = byte-rotl 5 + bit-shl 3
-      let d2_0 = u8_bit_decomposition(t12[0]);
-      let d2_1 = u8_bit_decomposition(t12[1]);
-      let d2_2 = u8_bit_decomposition(t12[2]);
-      let d2_3 = u8_bit_decomposition(t12[3]);
-      let d2_4 = u8_bit_decomposition(t12[4]);
-      let d2_5 = u8_bit_decomposition(t12[5]);
-      let d2_6 = u8_bit_decomposition(t12[6]);
-      let d2_7 = u8_bit_decomposition(t12[7]);
-      let b2 = [
-        u8_from_field_unsafe(d2_2[5] + 2 * d2_2[6] + 4 * d2_2[7] + 8 * d2_3[0] + 16 * d2_3[1] + 32 * d2_3[2] + 64 * d2_3[3] + 128 * d2_3[4]),
-        u8_from_field_unsafe(d2_3[5] + 2 * d2_3[6] + 4 * d2_3[7] + 8 * d2_4[0] + 16 * d2_4[1] + 32 * d2_4[2] + 64 * d2_4[3] + 128 * d2_4[4]),
-        u8_from_field_unsafe(d2_4[5] + 2 * d2_4[6] + 4 * d2_4[7] + 8 * d2_5[0] + 16 * d2_5[1] + 32 * d2_5[2] + 64 * d2_5[3] + 128 * d2_5[4]),
-        u8_from_field_unsafe(d2_5[5] + 2 * d2_5[6] + 4 * d2_5[7] + 8 * d2_6[0] + 16 * d2_6[1] + 32 * d2_6[2] + 64 * d2_6[3] + 128 * d2_6[4]),
-        u8_from_field_unsafe(d2_6[5] + 2 * d2_6[6] + 4 * d2_6[7] + 8 * d2_7[0] + 16 * d2_7[1] + 32 * d2_7[2] + 64 * d2_7[3] + 128 * d2_7[4]),
-        u8_from_field_unsafe(d2_7[5] + 2 * d2_7[6] + 4 * d2_7[7] + 8 * d2_0[0] + 16 * d2_0[1] + 32 * d2_0[2] + 64 * d2_0[3] + 128 * d2_0[4]),
-        u8_from_field_unsafe(d2_0[5] + 2 * d2_0[6] + 4 * d2_0[7] + 8 * d2_1[0] + 16 * d2_1[1] + 32 * d2_1[2] + 64 * d2_1[3] + 128 * d2_1[4]),
-        u8_from_field_unsafe(d2_1[5] + 2 * d2_1[6] + 4 * d2_1[7] + 8 * d2_2[0] + 16 * d2_2[1] + 32 * d2_2[2] + 64 * d2_2[3] + 128 * d2_2[4])
-      ];
-      -- b12 = rotl(t13, 25) = byte-rotl 3 + bit-shl 1
-      let d12_0 = u8_bit_decomposition(t13[0]);
-      let d12_1 = u8_bit_decomposition(t13[1]);
-      let d12_2 = u8_bit_decomposition(t13[2]);
-      let d12_3 = u8_bit_decomposition(t13[3]);
-      let d12_4 = u8_bit_decomposition(t13[4]);
-      let d12_5 = u8_bit_decomposition(t13[5]);
-      let d12_6 = u8_bit_decomposition(t13[6]);
-      let d12_7 = u8_bit_decomposition(t13[7]);
-      let b12 = [
-        u8_from_field_unsafe(d12_4[7] + 2 * d12_5[0] + 4 * d12_5[1] + 8 * d12_5[2] + 16 * d12_5[3] + 32 * d12_5[4] + 64 * d12_5[5] + 128 * d12_5[6]),
-        u8_from_field_unsafe(d12_5[7] + 2 * d12_6[0] + 4 * d12_6[1] + 8 * d12_6[2] + 16 * d12_6[3] + 32 * d12_6[4] + 64 * d12_6[5] + 128 * d12_6[6]),
-        u8_from_field_unsafe(d12_6[7] + 2 * d12_7[0] + 4 * d12_7[1] + 8 * d12_7[2] + 16 * d12_7[3] + 32 * d12_7[4] + 64 * d12_7[5] + 128 * d12_7[6]),
-        u8_from_field_unsafe(d12_7[7] + 2 * d12_0[0] + 4 * d12_0[1] + 8 * d12_0[2] + 16 * d12_0[3] + 32 * d12_0[4] + 64 * d12_0[5] + 128 * d12_0[6]),
-        u8_from_field_unsafe(d12_0[7] + 2 * d12_1[0] + 4 * d12_1[1] + 8 * d12_1[2] + 16 * d12_1[3] + 32 * d12_1[4] + 64 * d12_1[5] + 128 * d12_1[6]),
-        u8_from_field_unsafe(d12_1[7] + 2 * d12_2[0] + 4 * d12_2[1] + 8 * d12_2[2] + 16 * d12_2[3] + 32 * d12_2[4] + 64 * d12_2[5] + 128 * d12_2[6]),
-        u8_from_field_unsafe(d12_2[7] + 2 * d12_3[0] + 4 * d12_3[1] + 8 * d12_3[2] + 16 * d12_3[3] + 32 * d12_3[4] + 64 * d12_3[5] + 128 * d12_3[6]),
-        u8_from_field_unsafe(d12_3[7] + 2 * d12_4[0] + 4 * d12_4[1] + 8 * d12_4[2] + 16 * d12_4[3] + 32 * d12_4[4] + 64 * d12_4[5] + 128 * d12_4[6])
-      ];
-      -- b22 = rotl(t14, 39) = byte-rotl 4 + bit-shl 7
-      let d22_0 = u8_bit_decomposition(t14[0]);
-      let d22_1 = u8_bit_decomposition(t14[1]);
-      let d22_2 = u8_bit_decomposition(t14[2]);
-      let d22_3 = u8_bit_decomposition(t14[3]);
-      let d22_4 = u8_bit_decomposition(t14[4]);
-      let d22_5 = u8_bit_decomposition(t14[5]);
-      let d22_6 = u8_bit_decomposition(t14[6]);
-      let d22_7 = u8_bit_decomposition(t14[7]);
-      let b22 = [
-        u8_from_field_unsafe(d22_3[1] + 2 * d22_3[2] + 4 * d22_3[3] + 8 * d22_3[4] + 16 * d22_3[5] + 32 * d22_3[6] + 64 * d22_3[7] + 128 * d22_4[0]),
-        u8_from_field_unsafe(d22_4[1] + 2 * d22_4[2] + 4 * d22_4[3] + 8 * d22_4[4] + 16 * d22_4[5] + 32 * d22_4[6] + 64 * d22_4[7] + 128 * d22_5[0]),
-        u8_from_field_unsafe(d22_5[1] + 2 * d22_5[2] + 4 * d22_5[3] + 8 * d22_5[4] + 16 * d22_5[5] + 32 * d22_5[6] + 64 * d22_5[7] + 128 * d22_6[0]),
-        u8_from_field_unsafe(d22_6[1] + 2 * d22_6[2] + 4 * d22_6[3] + 8 * d22_6[4] + 16 * d22_6[5] + 32 * d22_6[6] + 64 * d22_6[7] + 128 * d22_7[0]),
-        u8_from_field_unsafe(d22_7[1] + 2 * d22_7[2] + 4 * d22_7[3] + 8 * d22_7[4] + 16 * d22_7[5] + 32 * d22_7[6] + 64 * d22_7[7] + 128 * d22_0[0]),
-        u8_from_field_unsafe(d22_0[1] + 2 * d22_0[2] + 4 * d22_0[3] + 8 * d22_0[4] + 16 * d22_0[5] + 32 * d22_0[6] + 64 * d22_0[7] + 128 * d22_1[0]),
-        u8_from_field_unsafe(d22_1[1] + 2 * d22_1[2] + 4 * d22_1[3] + 8 * d22_1[4] + 16 * d22_1[5] + 32 * d22_1[6] + 64 * d22_1[7] + 128 * d22_2[0]),
-        u8_from_field_unsafe(d22_2[1] + 2 * d22_2[2] + 4 * d22_2[3] + 8 * d22_2[4] + 16 * d22_2[5] + 32 * d22_2[6] + 64 * d22_2[7] + 128 * d22_3[0])
-      ];
-      -- b23 = rotl(t15, 41) = byte-rotl 5 + bit-shl 1
-      let d23_0 = u8_bit_decomposition(t15[0]);
-      let d23_1 = u8_bit_decomposition(t15[1]);
-      let d23_2 = u8_bit_decomposition(t15[2]);
-      let d23_3 = u8_bit_decomposition(t15[3]);
-      let d23_4 = u8_bit_decomposition(t15[4]);
-      let d23_5 = u8_bit_decomposition(t15[5]);
-      let d23_6 = u8_bit_decomposition(t15[6]);
-      let d23_7 = u8_bit_decomposition(t15[7]);
-      let b23 = [
-        u8_from_field_unsafe(d23_2[7] + 2 * d23_3[0] + 4 * d23_3[1] + 8 * d23_3[2] + 16 * d23_3[3] + 32 * d23_3[4] + 64 * d23_3[5] + 128 * d23_3[6]),
-        u8_from_field_unsafe(d23_3[7] + 2 * d23_4[0] + 4 * d23_4[1] + 8 * d23_4[2] + 16 * d23_4[3] + 32 * d23_4[4] + 64 * d23_4[5] + 128 * d23_4[6]),
-        u8_from_field_unsafe(d23_4[7] + 2 * d23_5[0] + 4 * d23_5[1] + 8 * d23_5[2] + 16 * d23_5[3] + 32 * d23_5[4] + 64 * d23_5[5] + 128 * d23_5[6]),
-        u8_from_field_unsafe(d23_5[7] + 2 * d23_6[0] + 4 * d23_6[1] + 8 * d23_6[2] + 16 * d23_6[3] + 32 * d23_6[4] + 64 * d23_6[5] + 128 * d23_6[6]),
-        u8_from_field_unsafe(d23_6[7] + 2 * d23_7[0] + 4 * d23_7[1] + 8 * d23_7[2] + 16 * d23_7[3] + 32 * d23_7[4] + 64 * d23_7[5] + 128 * d23_7[6]),
-        u8_from_field_unsafe(d23_7[7] + 2 * d23_0[0] + 4 * d23_0[1] + 8 * d23_0[2] + 16 * d23_0[3] + 32 * d23_0[4] + 64 * d23_0[5] + 128 * d23_0[6]),
-        u8_from_field_unsafe(d23_0[7] + 2 * d23_1[0] + 4 * d23_1[1] + 8 * d23_1[2] + 16 * d23_1[3] + 32 * d23_1[4] + 64 * d23_1[5] + 128 * d23_1[6]),
-        u8_from_field_unsafe(d23_1[7] + 2 * d23_2[0] + 4 * d23_2[1] + 8 * d23_2[2] + 16 * d23_2[3] + 32 * d23_2[4] + 64 * d23_2[5] + 128 * d23_2[6])
-      ];
-      -- b8 = rotl(t16, 45) = byte-rotl 5 + bit-shl 5
-      let d8_0 = u8_bit_decomposition(t16[0]);
-      let d8_1 = u8_bit_decomposition(t16[1]);
-      let d8_2 = u8_bit_decomposition(t16[2]);
-      let d8_3 = u8_bit_decomposition(t16[3]);
-      let d8_4 = u8_bit_decomposition(t16[4]);
-      let d8_5 = u8_bit_decomposition(t16[5]);
-      let d8_6 = u8_bit_decomposition(t16[6]);
-      let d8_7 = u8_bit_decomposition(t16[7]);
-      let b8 = [
-        u8_from_field_unsafe(d8_2[3] + 2 * d8_2[4] + 4 * d8_2[5] + 8 * d8_2[6] + 16 * d8_2[7] + 32 * d8_3[0] + 64 * d8_3[1] + 128 * d8_3[2]),
-        u8_from_field_unsafe(d8_3[3] + 2 * d8_3[4] + 4 * d8_3[5] + 8 * d8_3[6] + 16 * d8_3[7] + 32 * d8_4[0] + 64 * d8_4[1] + 128 * d8_4[2]),
-        u8_from_field_unsafe(d8_4[3] + 2 * d8_4[4] + 4 * d8_4[5] + 8 * d8_4[6] + 16 * d8_4[7] + 32 * d8_5[0] + 64 * d8_5[1] + 128 * d8_5[2]),
-        u8_from_field_unsafe(d8_5[3] + 2 * d8_5[4] + 4 * d8_5[5] + 8 * d8_5[6] + 16 * d8_5[7] + 32 * d8_6[0] + 64 * d8_6[1] + 128 * d8_6[2]),
-        u8_from_field_unsafe(d8_6[3] + 2 * d8_6[4] + 4 * d8_6[5] + 8 * d8_6[6] + 16 * d8_6[7] + 32 * d8_7[0] + 64 * d8_7[1] + 128 * d8_7[2]),
-        u8_from_field_unsafe(d8_7[3] + 2 * d8_7[4] + 4 * d8_7[5] + 8 * d8_7[6] + 16 * d8_7[7] + 32 * d8_0[0] + 64 * d8_0[1] + 128 * d8_0[2]),
-        u8_from_field_unsafe(d8_0[3] + 2 * d8_0[4] + 4 * d8_0[5] + 8 * d8_0[6] + 16 * d8_0[7] + 32 * d8_1[0] + 64 * d8_1[1] + 128 * d8_1[2]),
-        u8_from_field_unsafe(d8_1[3] + 2 * d8_1[4] + 4 * d8_1[5] + 8 * d8_1[6] + 16 * d8_1[7] + 32 * d8_2[0] + 64 * d8_2[1] + 128 * d8_2[2])
-      ];
-      -- b18 = rotl(t17, 15) = byte-rotl 1 + bit-shl 7
-      let d18_0 = u8_bit_decomposition(t17[0]);
-      let d18_1 = u8_bit_decomposition(t17[1]);
-      let d18_2 = u8_bit_decomposition(t17[2]);
-      let d18_3 = u8_bit_decomposition(t17[3]);
-      let d18_4 = u8_bit_decomposition(t17[4]);
-      let d18_5 = u8_bit_decomposition(t17[5]);
-      let d18_6 = u8_bit_decomposition(t17[6]);
-      let d18_7 = u8_bit_decomposition(t17[7]);
-      let b18 = [
-        u8_from_field_unsafe(d18_6[1] + 2 * d18_6[2] + 4 * d18_6[3] + 8 * d18_6[4] + 16 * d18_6[5] + 32 * d18_6[6] + 64 * d18_6[7] + 128 * d18_7[0]),
-        u8_from_field_unsafe(d18_7[1] + 2 * d18_7[2] + 4 * d18_7[3] + 8 * d18_7[4] + 16 * d18_7[5] + 32 * d18_7[6] + 64 * d18_7[7] + 128 * d18_0[0]),
-        u8_from_field_unsafe(d18_0[1] + 2 * d18_0[2] + 4 * d18_0[3] + 8 * d18_0[4] + 16 * d18_0[5] + 32 * d18_0[6] + 64 * d18_0[7] + 128 * d18_1[0]),
-        u8_from_field_unsafe(d18_1[1] + 2 * d18_1[2] + 4 * d18_1[3] + 8 * d18_1[4] + 16 * d18_1[5] + 32 * d18_1[6] + 64 * d18_1[7] + 128 * d18_2[0]),
-        u8_from_field_unsafe(d18_2[1] + 2 * d18_2[2] + 4 * d18_2[3] + 8 * d18_2[4] + 16 * d18_2[5] + 32 * d18_2[6] + 64 * d18_2[7] + 128 * d18_3[0]),
-        u8_from_field_unsafe(d18_3[1] + 2 * d18_3[2] + 4 * d18_3[3] + 8 * d18_3[4] + 16 * d18_3[5] + 32 * d18_3[6] + 64 * d18_3[7] + 128 * d18_4[0]),
-        u8_from_field_unsafe(d18_4[1] + 2 * d18_4[2] + 4 * d18_4[3] + 8 * d18_4[4] + 16 * d18_4[5] + 32 * d18_4[6] + 64 * d18_4[7] + 128 * d18_5[0]),
-        u8_from_field_unsafe(d18_5[1] + 2 * d18_5[2] + 4 * d18_5[3] + 8 * d18_5[4] + 16 * d18_5[5] + 32 * d18_5[6] + 64 * d18_5[7] + 128 * d18_6[0])
-      ];
-      -- b3 = rotl(t18, 21) = byte-rotl 2 + bit-shl 5
-      let d3_0 = u8_bit_decomposition(t18[0]);
-      let d3_1 = u8_bit_decomposition(t18[1]);
-      let d3_2 = u8_bit_decomposition(t18[2]);
-      let d3_3 = u8_bit_decomposition(t18[3]);
-      let d3_4 = u8_bit_decomposition(t18[4]);
-      let d3_5 = u8_bit_decomposition(t18[5]);
-      let d3_6 = u8_bit_decomposition(t18[6]);
-      let d3_7 = u8_bit_decomposition(t18[7]);
-      let b3 = [
-        u8_from_field_unsafe(d3_5[3] + 2 * d3_5[4] + 4 * d3_5[5] + 8 * d3_5[6] + 16 * d3_5[7] + 32 * d3_6[0] + 64 * d3_6[1] + 128 * d3_6[2]),
-        u8_from_field_unsafe(d3_6[3] + 2 * d3_6[4] + 4 * d3_6[5] + 8 * d3_6[6] + 16 * d3_6[7] + 32 * d3_7[0] + 64 * d3_7[1] + 128 * d3_7[2]),
-        u8_from_field_unsafe(d3_7[3] + 2 * d3_7[4] + 4 * d3_7[5] + 8 * d3_7[6] + 16 * d3_7[7] + 32 * d3_0[0] + 64 * d3_0[1] + 128 * d3_0[2]),
-        u8_from_field_unsafe(d3_0[3] + 2 * d3_0[4] + 4 * d3_0[5] + 8 * d3_0[6] + 16 * d3_0[7] + 32 * d3_1[0] + 64 * d3_1[1] + 128 * d3_1[2]),
-        u8_from_field_unsafe(d3_1[3] + 2 * d3_1[4] + 4 * d3_1[5] + 8 * d3_1[6] + 16 * d3_1[7] + 32 * d3_2[0] + 64 * d3_2[1] + 128 * d3_2[2]),
-        u8_from_field_unsafe(d3_2[3] + 2 * d3_2[4] + 4 * d3_2[5] + 8 * d3_2[6] + 16 * d3_2[7] + 32 * d3_3[0] + 64 * d3_3[1] + 128 * d3_3[2]),
-        u8_from_field_unsafe(d3_3[3] + 2 * d3_3[4] + 4 * d3_3[5] + 8 * d3_3[6] + 16 * d3_3[7] + 32 * d3_4[0] + 64 * d3_4[1] + 128 * d3_4[2]),
-        u8_from_field_unsafe(d3_4[3] + 2 * d3_4[4] + 4 * d3_4[5] + 8 * d3_4[6] + 16 * d3_4[7] + 32 * d3_5[0] + 64 * d3_5[1] + 128 * d3_5[2])
-      ];
+      let b6 = [u8_from_field_unsafe(d6_5[4] + 2 * d6_5[5] + 4 * d6_5[6] + 8 * d6_5[7] + 16 * d6_6[0] + 32 * d6_6[1] + 64 * d6_6[2] + 128 * d6_6[3]), u8_from_field_unsafe(d6_6[4] + 2 * d6_6[5] + 4 * d6_6[6] + 8 * d6_6[7] + 16 * d6_7[0] + 32 * d6_7[1] + 64 * d6_7[2] + 128 * d6_7[3]), u8_from_field_unsafe(d6_7[4] + 2 * d6_7[5] + 4 * d6_7[6] + 8 * d6_7[7] + 16 * d6_0[0] + 32 * d6_0[1] + 64 * d6_0[2] + 128 * d6_0[3]), u8_from_field_unsafe(d6_0[4] + 2 * d6_0[5] + 4 * d6_0[6] + 8 * d6_0[7] + 16 * d6_1[0] + 32 * d6_1[1] + 64 * d6_1[2] + 128 * d6_1[3]), u8_from_field_unsafe(d6_1[4] + 2 * d6_1[5] + 4 * d6_1[6] + 8 * d6_1[7] + 16 * d6_2[0] + 32 * d6_2[1] + 64 * d6_2[2] + 128 * d6_2[3]), u8_from_field_unsafe(d6_2[4] + 2 * d6_2[5] + 4 * d6_2[6] + 8 * d6_2[7] + 16 * d6_3[0] + 32 * d6_3[1] + 64 * d6_3[2] + 128 * d6_3[3]), u8_from_field_unsafe(d6_3[4] + 2 * d6_3[5] + 4 * d6_3[6] + 8 * d6_3[7] + 16 * d6_4[0] + 32 * d6_4[1] + 64 * d6_4[2] + 128 * d6_4[3]), u8_from_field_unsafe(d6_4[4] + 2 * d6_4[5] + 4 * d6_4[6] + 8 * d6_4[7] + 16 * d6_5[0] + 32 * d6_5[1] + 64 * d6_5[2] + 128 * d6_5[3])];
+      -- b7 = rotl(t10, 3) = byte-rotl 0 + 3x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a7_0_0, c7_0_0) = u8_add(t10[0], t10[0]);
+      let (a7_0_1, c7_0_1) = u8_add(t10[1], t10[1]);
+      let (a7_0_2, c7_0_2) = u8_add(t10[2], t10[2]);
+      let (a7_0_3, c7_0_3) = u8_add(t10[3], t10[3]);
+      let (a7_0_4, c7_0_4) = u8_add(t10[4], t10[4]);
+      let (a7_0_5, c7_0_5) = u8_add(t10[5], t10[5]);
+      let (a7_0_6, c7_0_6) = u8_add(t10[6], t10[6]);
+      let (a7_0_7, c7_0_7) = u8_add(t10[7], t10[7]);
+      let (a7_1_0, c7_1_0) = u8_add(u8_from_field_unsafe(to_field(a7_0_0) + to_field(c7_0_7)), u8_from_field_unsafe(to_field(a7_0_0) + to_field(c7_0_7)));
+      let (a7_1_1, c7_1_1) = u8_add(u8_from_field_unsafe(to_field(a7_0_1) + to_field(c7_0_0)), u8_from_field_unsafe(to_field(a7_0_1) + to_field(c7_0_0)));
+      let (a7_1_2, c7_1_2) = u8_add(u8_from_field_unsafe(to_field(a7_0_2) + to_field(c7_0_1)), u8_from_field_unsafe(to_field(a7_0_2) + to_field(c7_0_1)));
+      let (a7_1_3, c7_1_3) = u8_add(u8_from_field_unsafe(to_field(a7_0_3) + to_field(c7_0_2)), u8_from_field_unsafe(to_field(a7_0_3) + to_field(c7_0_2)));
+      let (a7_1_4, c7_1_4) = u8_add(u8_from_field_unsafe(to_field(a7_0_4) + to_field(c7_0_3)), u8_from_field_unsafe(to_field(a7_0_4) + to_field(c7_0_3)));
+      let (a7_1_5, c7_1_5) = u8_add(u8_from_field_unsafe(to_field(a7_0_5) + to_field(c7_0_4)), u8_from_field_unsafe(to_field(a7_0_5) + to_field(c7_0_4)));
+      let (a7_1_6, c7_1_6) = u8_add(u8_from_field_unsafe(to_field(a7_0_6) + to_field(c7_0_5)), u8_from_field_unsafe(to_field(a7_0_6) + to_field(c7_0_5)));
+      let (a7_1_7, c7_1_7) = u8_add(u8_from_field_unsafe(to_field(a7_0_7) + to_field(c7_0_6)), u8_from_field_unsafe(to_field(a7_0_7) + to_field(c7_0_6)));
+      let (a7_2_0, c7_2_0) = u8_add(u8_from_field_unsafe(to_field(a7_1_0) + to_field(c7_1_7)), u8_from_field_unsafe(to_field(a7_1_0) + to_field(c7_1_7)));
+      let (a7_2_1, c7_2_1) = u8_add(u8_from_field_unsafe(to_field(a7_1_1) + to_field(c7_1_0)), u8_from_field_unsafe(to_field(a7_1_1) + to_field(c7_1_0)));
+      let (a7_2_2, c7_2_2) = u8_add(u8_from_field_unsafe(to_field(a7_1_2) + to_field(c7_1_1)), u8_from_field_unsafe(to_field(a7_1_2) + to_field(c7_1_1)));
+      let (a7_2_3, c7_2_3) = u8_add(u8_from_field_unsafe(to_field(a7_1_3) + to_field(c7_1_2)), u8_from_field_unsafe(to_field(a7_1_3) + to_field(c7_1_2)));
+      let (a7_2_4, c7_2_4) = u8_add(u8_from_field_unsafe(to_field(a7_1_4) + to_field(c7_1_3)), u8_from_field_unsafe(to_field(a7_1_4) + to_field(c7_1_3)));
+      let (a7_2_5, c7_2_5) = u8_add(u8_from_field_unsafe(to_field(a7_1_5) + to_field(c7_1_4)), u8_from_field_unsafe(to_field(a7_1_5) + to_field(c7_1_4)));
+      let (a7_2_6, c7_2_6) = u8_add(u8_from_field_unsafe(to_field(a7_1_6) + to_field(c7_1_5)), u8_from_field_unsafe(to_field(a7_1_6) + to_field(c7_1_5)));
+      let (a7_2_7, c7_2_7) = u8_add(u8_from_field_unsafe(to_field(a7_1_7) + to_field(c7_1_6)), u8_from_field_unsafe(to_field(a7_1_7) + to_field(c7_1_6)));
+      let b7 = [u8_from_field_unsafe(to_field(a7_2_0) + to_field(c7_2_7)), u8_from_field_unsafe(to_field(a7_2_1) + to_field(c7_2_0)), u8_from_field_unsafe(to_field(a7_2_2) + to_field(c7_2_1)), u8_from_field_unsafe(to_field(a7_2_3) + to_field(c7_2_2)), u8_from_field_unsafe(to_field(a7_2_4) + to_field(c7_2_3)), u8_from_field_unsafe(to_field(a7_2_5) + to_field(c7_2_4)), u8_from_field_unsafe(to_field(a7_2_6) + to_field(c7_2_5)), u8_from_field_unsafe(to_field(a7_2_7) + to_field(c7_2_6))];
+      -- b17 = rotl(t11, 10) = byte-rotl 1 + 2x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a17_0_0, c17_0_0) = u8_add(t11[7], t11[7]);
+      let (a17_0_1, c17_0_1) = u8_add(t11[0], t11[0]);
+      let (a17_0_2, c17_0_2) = u8_add(t11[1], t11[1]);
+      let (a17_0_3, c17_0_3) = u8_add(t11[2], t11[2]);
+      let (a17_0_4, c17_0_4) = u8_add(t11[3], t11[3]);
+      let (a17_0_5, c17_0_5) = u8_add(t11[4], t11[4]);
+      let (a17_0_6, c17_0_6) = u8_add(t11[5], t11[5]);
+      let (a17_0_7, c17_0_7) = u8_add(t11[6], t11[6]);
+      let (a17_1_0, c17_1_0) = u8_add(u8_from_field_unsafe(to_field(a17_0_0) + to_field(c17_0_7)), u8_from_field_unsafe(to_field(a17_0_0) + to_field(c17_0_7)));
+      let (a17_1_1, c17_1_1) = u8_add(u8_from_field_unsafe(to_field(a17_0_1) + to_field(c17_0_0)), u8_from_field_unsafe(to_field(a17_0_1) + to_field(c17_0_0)));
+      let (a17_1_2, c17_1_2) = u8_add(u8_from_field_unsafe(to_field(a17_0_2) + to_field(c17_0_1)), u8_from_field_unsafe(to_field(a17_0_2) + to_field(c17_0_1)));
+      let (a17_1_3, c17_1_3) = u8_add(u8_from_field_unsafe(to_field(a17_0_3) + to_field(c17_0_2)), u8_from_field_unsafe(to_field(a17_0_3) + to_field(c17_0_2)));
+      let (a17_1_4, c17_1_4) = u8_add(u8_from_field_unsafe(to_field(a17_0_4) + to_field(c17_0_3)), u8_from_field_unsafe(to_field(a17_0_4) + to_field(c17_0_3)));
+      let (a17_1_5, c17_1_5) = u8_add(u8_from_field_unsafe(to_field(a17_0_5) + to_field(c17_0_4)), u8_from_field_unsafe(to_field(a17_0_5) + to_field(c17_0_4)));
+      let (a17_1_6, c17_1_6) = u8_add(u8_from_field_unsafe(to_field(a17_0_6) + to_field(c17_0_5)), u8_from_field_unsafe(to_field(a17_0_6) + to_field(c17_0_5)));
+      let (a17_1_7, c17_1_7) = u8_add(u8_from_field_unsafe(to_field(a17_0_7) + to_field(c17_0_6)), u8_from_field_unsafe(to_field(a17_0_7) + to_field(c17_0_6)));
+      let b17 = [u8_from_field_unsafe(to_field(a17_1_0) + to_field(c17_1_7)), u8_from_field_unsafe(to_field(a17_1_1) + to_field(c17_1_0)), u8_from_field_unsafe(to_field(a17_1_2) + to_field(c17_1_1)), u8_from_field_unsafe(to_field(a17_1_3) + to_field(c17_1_2)), u8_from_field_unsafe(to_field(a17_1_4) + to_field(c17_1_3)), u8_from_field_unsafe(to_field(a17_1_5) + to_field(c17_1_4)), u8_from_field_unsafe(to_field(a17_1_6) + to_field(c17_1_5)), u8_from_field_unsafe(to_field(a17_1_7) + to_field(c17_1_6))];
+      -- b2 = rotl(t12, 43) = byte-rotl 5 + 3x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a2_0_0, c2_0_0) = u8_add(t12[3], t12[3]);
+      let (a2_0_1, c2_0_1) = u8_add(t12[4], t12[4]);
+      let (a2_0_2, c2_0_2) = u8_add(t12[5], t12[5]);
+      let (a2_0_3, c2_0_3) = u8_add(t12[6], t12[6]);
+      let (a2_0_4, c2_0_4) = u8_add(t12[7], t12[7]);
+      let (a2_0_5, c2_0_5) = u8_add(t12[0], t12[0]);
+      let (a2_0_6, c2_0_6) = u8_add(t12[1], t12[1]);
+      let (a2_0_7, c2_0_7) = u8_add(t12[2], t12[2]);
+      let (a2_1_0, c2_1_0) = u8_add(u8_from_field_unsafe(to_field(a2_0_0) + to_field(c2_0_7)), u8_from_field_unsafe(to_field(a2_0_0) + to_field(c2_0_7)));
+      let (a2_1_1, c2_1_1) = u8_add(u8_from_field_unsafe(to_field(a2_0_1) + to_field(c2_0_0)), u8_from_field_unsafe(to_field(a2_0_1) + to_field(c2_0_0)));
+      let (a2_1_2, c2_1_2) = u8_add(u8_from_field_unsafe(to_field(a2_0_2) + to_field(c2_0_1)), u8_from_field_unsafe(to_field(a2_0_2) + to_field(c2_0_1)));
+      let (a2_1_3, c2_1_3) = u8_add(u8_from_field_unsafe(to_field(a2_0_3) + to_field(c2_0_2)), u8_from_field_unsafe(to_field(a2_0_3) + to_field(c2_0_2)));
+      let (a2_1_4, c2_1_4) = u8_add(u8_from_field_unsafe(to_field(a2_0_4) + to_field(c2_0_3)), u8_from_field_unsafe(to_field(a2_0_4) + to_field(c2_0_3)));
+      let (a2_1_5, c2_1_5) = u8_add(u8_from_field_unsafe(to_field(a2_0_5) + to_field(c2_0_4)), u8_from_field_unsafe(to_field(a2_0_5) + to_field(c2_0_4)));
+      let (a2_1_6, c2_1_6) = u8_add(u8_from_field_unsafe(to_field(a2_0_6) + to_field(c2_0_5)), u8_from_field_unsafe(to_field(a2_0_6) + to_field(c2_0_5)));
+      let (a2_1_7, c2_1_7) = u8_add(u8_from_field_unsafe(to_field(a2_0_7) + to_field(c2_0_6)), u8_from_field_unsafe(to_field(a2_0_7) + to_field(c2_0_6)));
+      let (a2_2_0, c2_2_0) = u8_add(u8_from_field_unsafe(to_field(a2_1_0) + to_field(c2_1_7)), u8_from_field_unsafe(to_field(a2_1_0) + to_field(c2_1_7)));
+      let (a2_2_1, c2_2_1) = u8_add(u8_from_field_unsafe(to_field(a2_1_1) + to_field(c2_1_0)), u8_from_field_unsafe(to_field(a2_1_1) + to_field(c2_1_0)));
+      let (a2_2_2, c2_2_2) = u8_add(u8_from_field_unsafe(to_field(a2_1_2) + to_field(c2_1_1)), u8_from_field_unsafe(to_field(a2_1_2) + to_field(c2_1_1)));
+      let (a2_2_3, c2_2_3) = u8_add(u8_from_field_unsafe(to_field(a2_1_3) + to_field(c2_1_2)), u8_from_field_unsafe(to_field(a2_1_3) + to_field(c2_1_2)));
+      let (a2_2_4, c2_2_4) = u8_add(u8_from_field_unsafe(to_field(a2_1_4) + to_field(c2_1_3)), u8_from_field_unsafe(to_field(a2_1_4) + to_field(c2_1_3)));
+      let (a2_2_5, c2_2_5) = u8_add(u8_from_field_unsafe(to_field(a2_1_5) + to_field(c2_1_4)), u8_from_field_unsafe(to_field(a2_1_5) + to_field(c2_1_4)));
+      let (a2_2_6, c2_2_6) = u8_add(u8_from_field_unsafe(to_field(a2_1_6) + to_field(c2_1_5)), u8_from_field_unsafe(to_field(a2_1_6) + to_field(c2_1_5)));
+      let (a2_2_7, c2_2_7) = u8_add(u8_from_field_unsafe(to_field(a2_1_7) + to_field(c2_1_6)), u8_from_field_unsafe(to_field(a2_1_7) + to_field(c2_1_6)));
+      let b2 = [u8_from_field_unsafe(to_field(a2_2_0) + to_field(c2_2_7)), u8_from_field_unsafe(to_field(a2_2_1) + to_field(c2_2_0)), u8_from_field_unsafe(to_field(a2_2_2) + to_field(c2_2_1)), u8_from_field_unsafe(to_field(a2_2_3) + to_field(c2_2_2)), u8_from_field_unsafe(to_field(a2_2_4) + to_field(c2_2_3)), u8_from_field_unsafe(to_field(a2_2_5) + to_field(c2_2_4)), u8_from_field_unsafe(to_field(a2_2_6) + to_field(c2_2_5)), u8_from_field_unsafe(to_field(a2_2_7) + to_field(c2_2_6))];
+      -- b12 = rotl(t13, 25) = byte-rotl 3 + 1x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a12_0_0, c12_0_0) = u8_add(t13[5], t13[5]);
+      let (a12_0_1, c12_0_1) = u8_add(t13[6], t13[6]);
+      let (a12_0_2, c12_0_2) = u8_add(t13[7], t13[7]);
+      let (a12_0_3, c12_0_3) = u8_add(t13[0], t13[0]);
+      let (a12_0_4, c12_0_4) = u8_add(t13[1], t13[1]);
+      let (a12_0_5, c12_0_5) = u8_add(t13[2], t13[2]);
+      let (a12_0_6, c12_0_6) = u8_add(t13[3], t13[3]);
+      let (a12_0_7, c12_0_7) = u8_add(t13[4], t13[4]);
+      let b12 = [u8_from_field_unsafe(to_field(a12_0_0) + to_field(c12_0_7)), u8_from_field_unsafe(to_field(a12_0_1) + to_field(c12_0_0)), u8_from_field_unsafe(to_field(a12_0_2) + to_field(c12_0_1)), u8_from_field_unsafe(to_field(a12_0_3) + to_field(c12_0_2)), u8_from_field_unsafe(to_field(a12_0_4) + to_field(c12_0_3)), u8_from_field_unsafe(to_field(a12_0_5) + to_field(c12_0_4)), u8_from_field_unsafe(to_field(a12_0_6) + to_field(c12_0_5)), u8_from_field_unsafe(to_field(a12_0_7) + to_field(c12_0_6))];
+      -- b22 = rotl(t14, 39) = byte-rotl 5 + 1x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h22_0_0 = u8_shift_right(t14[3]);
+      let h22_0_1 = u8_shift_right(t14[4]);
+      let h22_0_2 = u8_shift_right(t14[5]);
+      let h22_0_3 = u8_shift_right(t14[6]);
+      let h22_0_4 = u8_shift_right(t14[7]);
+      let h22_0_5 = u8_shift_right(t14[0]);
+      let h22_0_6 = u8_shift_right(t14[1]);
+      let h22_0_7 = u8_shift_right(t14[2]);
+      let b22 = [u8_from_field_unsafe(to_field(h22_0_0) + 128 * (to_field(t14[4]) - 2 * to_field(h22_0_1))), u8_from_field_unsafe(to_field(h22_0_1) + 128 * (to_field(t14[5]) - 2 * to_field(h22_0_2))), u8_from_field_unsafe(to_field(h22_0_2) + 128 * (to_field(t14[6]) - 2 * to_field(h22_0_3))), u8_from_field_unsafe(to_field(h22_0_3) + 128 * (to_field(t14[7]) - 2 * to_field(h22_0_4))), u8_from_field_unsafe(to_field(h22_0_4) + 128 * (to_field(t14[0]) - 2 * to_field(h22_0_5))), u8_from_field_unsafe(to_field(h22_0_5) + 128 * (to_field(t14[1]) - 2 * to_field(h22_0_6))), u8_from_field_unsafe(to_field(h22_0_6) + 128 * (to_field(t14[2]) - 2 * to_field(h22_0_7))), u8_from_field_unsafe(to_field(h22_0_7) + 128 * (to_field(t14[3]) - 2 * to_field(h22_0_0)))];
+      -- b23 = rotl(t15, 41) = byte-rotl 5 + 1x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a23_0_0, c23_0_0) = u8_add(t15[3], t15[3]);
+      let (a23_0_1, c23_0_1) = u8_add(t15[4], t15[4]);
+      let (a23_0_2, c23_0_2) = u8_add(t15[5], t15[5]);
+      let (a23_0_3, c23_0_3) = u8_add(t15[6], t15[6]);
+      let (a23_0_4, c23_0_4) = u8_add(t15[7], t15[7]);
+      let (a23_0_5, c23_0_5) = u8_add(t15[0], t15[0]);
+      let (a23_0_6, c23_0_6) = u8_add(t15[1], t15[1]);
+      let (a23_0_7, c23_0_7) = u8_add(t15[2], t15[2]);
+      let b23 = [u8_from_field_unsafe(to_field(a23_0_0) + to_field(c23_0_7)), u8_from_field_unsafe(to_field(a23_0_1) + to_field(c23_0_0)), u8_from_field_unsafe(to_field(a23_0_2) + to_field(c23_0_1)), u8_from_field_unsafe(to_field(a23_0_3) + to_field(c23_0_2)), u8_from_field_unsafe(to_field(a23_0_4) + to_field(c23_0_3)), u8_from_field_unsafe(to_field(a23_0_5) + to_field(c23_0_4)), u8_from_field_unsafe(to_field(a23_0_6) + to_field(c23_0_5)), u8_from_field_unsafe(to_field(a23_0_7) + to_field(c23_0_6))];
+      -- b8 = rotl(t16, 45) = byte-rotl 6 + 3x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h8_0_0 = u8_shift_right(t16[2]);
+      let h8_0_1 = u8_shift_right(t16[3]);
+      let h8_0_2 = u8_shift_right(t16[4]);
+      let h8_0_3 = u8_shift_right(t16[5]);
+      let h8_0_4 = u8_shift_right(t16[6]);
+      let h8_0_5 = u8_shift_right(t16[7]);
+      let h8_0_6 = u8_shift_right(t16[0]);
+      let h8_0_7 = u8_shift_right(t16[1]);
+      let h8_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0) + 128 * (to_field(t16[3]) - 2 * to_field(h8_0_1))));
+      let h8_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1) + 128 * (to_field(t16[4]) - 2 * to_field(h8_0_2))));
+      let h8_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_2) + 128 * (to_field(t16[5]) - 2 * to_field(h8_0_3))));
+      let h8_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_3) + 128 * (to_field(t16[6]) - 2 * to_field(h8_0_4))));
+      let h8_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_4) + 128 * (to_field(t16[7]) - 2 * to_field(h8_0_5))));
+      let h8_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_5) + 128 * (to_field(t16[0]) - 2 * to_field(h8_0_6))));
+      let h8_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_6) + 128 * (to_field(t16[1]) - 2 * to_field(h8_0_7))));
+      let h8_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_7) + 128 * (to_field(t16[2]) - 2 * to_field(h8_0_0))));
+      let h8_2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1) + 128 * (to_field(t16[4]) - 2 * to_field(h8_0_2)))) - 2 * to_field(h8_1_1))));
+      let h8_2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_2) + 128 * (to_field(t16[5]) - 2 * to_field(h8_0_3)))) - 2 * to_field(h8_1_2))));
+      let h8_2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_3) + 128 * (to_field(t16[6]) - 2 * to_field(h8_0_4)))) - 2 * to_field(h8_1_3))));
+      let h8_2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_4) + 128 * (to_field(t16[7]) - 2 * to_field(h8_0_5)))) - 2 * to_field(h8_1_4))));
+      let h8_2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_5) + 128 * (to_field(t16[0]) - 2 * to_field(h8_0_6)))) - 2 * to_field(h8_1_5))));
+      let h8_2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_6) + 128 * (to_field(t16[1]) - 2 * to_field(h8_0_7)))) - 2 * to_field(h8_1_6))));
+      let h8_2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_7) + 128 * (to_field(t16[2]) - 2 * to_field(h8_0_0)))) - 2 * to_field(h8_1_7))));
+      let h8_2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0) + 128 * (to_field(t16[3]) - 2 * to_field(h8_0_1)))) - 2 * to_field(h8_1_0))));
+      let b8 = [u8_from_field_unsafe(to_field(h8_2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_2) + 128 * (to_field(t16[5]) - 2 * to_field(h8_0_3)))) - 2 * to_field(h8_1_2)))) - 2 * to_field(h8_2_1))), u8_from_field_unsafe(to_field(h8_2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_3) + 128 * (to_field(t16[6]) - 2 * to_field(h8_0_4)))) - 2 * to_field(h8_1_3)))) - 2 * to_field(h8_2_2))), u8_from_field_unsafe(to_field(h8_2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_4) + 128 * (to_field(t16[7]) - 2 * to_field(h8_0_5)))) - 2 * to_field(h8_1_4)))) - 2 * to_field(h8_2_3))), u8_from_field_unsafe(to_field(h8_2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_5) + 128 * (to_field(t16[0]) - 2 * to_field(h8_0_6)))) - 2 * to_field(h8_1_5)))) - 2 * to_field(h8_2_4))), u8_from_field_unsafe(to_field(h8_2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_6) + 128 * (to_field(t16[1]) - 2 * to_field(h8_0_7)))) - 2 * to_field(h8_1_6)))) - 2 * to_field(h8_2_5))), u8_from_field_unsafe(to_field(h8_2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_7) + 128 * (to_field(t16[2]) - 2 * to_field(h8_0_0)))) - 2 * to_field(h8_1_7)))) - 2 * to_field(h8_2_6))), u8_from_field_unsafe(to_field(h8_2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0) + 128 * (to_field(t16[3]) - 2 * to_field(h8_0_1)))) - 2 * to_field(h8_1_0)))) - 2 * to_field(h8_2_7))), u8_from_field_unsafe(to_field(h8_2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1) + 128 * (to_field(t16[4]) - 2 * to_field(h8_0_2)))) - 2 * to_field(h8_1_1)))) - 2 * to_field(h8_2_0)))];
+      -- b18 = rotl(t17, 15) = byte-rotl 2 + 1x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h18_0_0 = u8_shift_right(t17[6]);
+      let h18_0_1 = u8_shift_right(t17[7]);
+      let h18_0_2 = u8_shift_right(t17[0]);
+      let h18_0_3 = u8_shift_right(t17[1]);
+      let h18_0_4 = u8_shift_right(t17[2]);
+      let h18_0_5 = u8_shift_right(t17[3]);
+      let h18_0_6 = u8_shift_right(t17[4]);
+      let h18_0_7 = u8_shift_right(t17[5]);
+      let b18 = [u8_from_field_unsafe(to_field(h18_0_0) + 128 * (to_field(t17[7]) - 2 * to_field(h18_0_1))), u8_from_field_unsafe(to_field(h18_0_1) + 128 * (to_field(t17[0]) - 2 * to_field(h18_0_2))), u8_from_field_unsafe(to_field(h18_0_2) + 128 * (to_field(t17[1]) - 2 * to_field(h18_0_3))), u8_from_field_unsafe(to_field(h18_0_3) + 128 * (to_field(t17[2]) - 2 * to_field(h18_0_4))), u8_from_field_unsafe(to_field(h18_0_4) + 128 * (to_field(t17[3]) - 2 * to_field(h18_0_5))), u8_from_field_unsafe(to_field(h18_0_5) + 128 * (to_field(t17[4]) - 2 * to_field(h18_0_6))), u8_from_field_unsafe(to_field(h18_0_6) + 128 * (to_field(t17[5]) - 2 * to_field(h18_0_7))), u8_from_field_unsafe(to_field(h18_0_7) + 128 * (to_field(t17[6]) - 2 * to_field(h18_0_0)))];
+      -- b3 = rotl(t18, 21) = byte-rotl 3 + 3x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h3_0_0 = u8_shift_right(t18[5]);
+      let h3_0_1 = u8_shift_right(t18[6]);
+      let h3_0_2 = u8_shift_right(t18[7]);
+      let h3_0_3 = u8_shift_right(t18[0]);
+      let h3_0_4 = u8_shift_right(t18[1]);
+      let h3_0_5 = u8_shift_right(t18[2]);
+      let h3_0_6 = u8_shift_right(t18[3]);
+      let h3_0_7 = u8_shift_right(t18[4]);
+      let h3_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0) + 128 * (to_field(t18[6]) - 2 * to_field(h3_0_1))));
+      let h3_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1) + 128 * (to_field(t18[7]) - 2 * to_field(h3_0_2))));
+      let h3_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_2) + 128 * (to_field(t18[0]) - 2 * to_field(h3_0_3))));
+      let h3_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_3) + 128 * (to_field(t18[1]) - 2 * to_field(h3_0_4))));
+      let h3_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_4) + 128 * (to_field(t18[2]) - 2 * to_field(h3_0_5))));
+      let h3_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_5) + 128 * (to_field(t18[3]) - 2 * to_field(h3_0_6))));
+      let h3_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_6) + 128 * (to_field(t18[4]) - 2 * to_field(h3_0_7))));
+      let h3_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_7) + 128 * (to_field(t18[5]) - 2 * to_field(h3_0_0))));
+      let h3_2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1) + 128 * (to_field(t18[7]) - 2 * to_field(h3_0_2)))) - 2 * to_field(h3_1_1))));
+      let h3_2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_2) + 128 * (to_field(t18[0]) - 2 * to_field(h3_0_3)))) - 2 * to_field(h3_1_2))));
+      let h3_2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_3) + 128 * (to_field(t18[1]) - 2 * to_field(h3_0_4)))) - 2 * to_field(h3_1_3))));
+      let h3_2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_4) + 128 * (to_field(t18[2]) - 2 * to_field(h3_0_5)))) - 2 * to_field(h3_1_4))));
+      let h3_2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_5) + 128 * (to_field(t18[3]) - 2 * to_field(h3_0_6)))) - 2 * to_field(h3_1_5))));
+      let h3_2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_6) + 128 * (to_field(t18[4]) - 2 * to_field(h3_0_7)))) - 2 * to_field(h3_1_6))));
+      let h3_2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_7) + 128 * (to_field(t18[5]) - 2 * to_field(h3_0_0)))) - 2 * to_field(h3_1_7))));
+      let h3_2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0) + 128 * (to_field(t18[6]) - 2 * to_field(h3_0_1)))) - 2 * to_field(h3_1_0))));
+      let b3 = [u8_from_field_unsafe(to_field(h3_2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_2) + 128 * (to_field(t18[0]) - 2 * to_field(h3_0_3)))) - 2 * to_field(h3_1_2)))) - 2 * to_field(h3_2_1))), u8_from_field_unsafe(to_field(h3_2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_3) + 128 * (to_field(t18[1]) - 2 * to_field(h3_0_4)))) - 2 * to_field(h3_1_3)))) - 2 * to_field(h3_2_2))), u8_from_field_unsafe(to_field(h3_2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_4) + 128 * (to_field(t18[2]) - 2 * to_field(h3_0_5)))) - 2 * to_field(h3_1_4)))) - 2 * to_field(h3_2_3))), u8_from_field_unsafe(to_field(h3_2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_5) + 128 * (to_field(t18[3]) - 2 * to_field(h3_0_6)))) - 2 * to_field(h3_1_5)))) - 2 * to_field(h3_2_4))), u8_from_field_unsafe(to_field(h3_2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_6) + 128 * (to_field(t18[4]) - 2 * to_field(h3_0_7)))) - 2 * to_field(h3_1_6)))) - 2 * to_field(h3_2_5))), u8_from_field_unsafe(to_field(h3_2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_7) + 128 * (to_field(t18[5]) - 2 * to_field(h3_0_0)))) - 2 * to_field(h3_1_7)))) - 2 * to_field(h3_2_6))), u8_from_field_unsafe(to_field(h3_2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0) + 128 * (to_field(t18[6]) - 2 * to_field(h3_0_1)))) - 2 * to_field(h3_1_0)))) - 2 * to_field(h3_2_7))), u8_from_field_unsafe(to_field(h3_2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1) + 128 * (to_field(t18[7]) - 2 * to_field(h3_0_2)))) - 2 * to_field(h3_1_1)))) - 2 * to_field(h3_2_0)))];
       -- b13 = rotl(t19, 8): byte rotation only (free)
       let b13 = [t19[7], t19[0], t19[1], t19[2], t19[3], t19[4], t19[5], t19[6]];
-      -- b14 = rotl(t20, 18) = byte-rotl 2 + bit-shl 2
-      let d14_0 = u8_bit_decomposition(t20[0]);
-      let d14_1 = u8_bit_decomposition(t20[1]);
-      let d14_2 = u8_bit_decomposition(t20[2]);
-      let d14_3 = u8_bit_decomposition(t20[3]);
-      let d14_4 = u8_bit_decomposition(t20[4]);
-      let d14_5 = u8_bit_decomposition(t20[5]);
-      let d14_6 = u8_bit_decomposition(t20[6]);
-      let d14_7 = u8_bit_decomposition(t20[7]);
-      let b14 = [
-        u8_from_field_unsafe(d14_5[6] + 2 * d14_5[7] + 4 * d14_6[0] + 8 * d14_6[1] + 16 * d14_6[2] + 32 * d14_6[3] + 64 * d14_6[4] + 128 * d14_6[5]),
-        u8_from_field_unsafe(d14_6[6] + 2 * d14_6[7] + 4 * d14_7[0] + 8 * d14_7[1] + 16 * d14_7[2] + 32 * d14_7[3] + 64 * d14_7[4] + 128 * d14_7[5]),
-        u8_from_field_unsafe(d14_7[6] + 2 * d14_7[7] + 4 * d14_0[0] + 8 * d14_0[1] + 16 * d14_0[2] + 32 * d14_0[3] + 64 * d14_0[4] + 128 * d14_0[5]),
-        u8_from_field_unsafe(d14_0[6] + 2 * d14_0[7] + 4 * d14_1[0] + 8 * d14_1[1] + 16 * d14_1[2] + 32 * d14_1[3] + 64 * d14_1[4] + 128 * d14_1[5]),
-        u8_from_field_unsafe(d14_1[6] + 2 * d14_1[7] + 4 * d14_2[0] + 8 * d14_2[1] + 16 * d14_2[2] + 32 * d14_2[3] + 64 * d14_2[4] + 128 * d14_2[5]),
-        u8_from_field_unsafe(d14_2[6] + 2 * d14_2[7] + 4 * d14_3[0] + 8 * d14_3[1] + 16 * d14_3[2] + 32 * d14_3[3] + 64 * d14_3[4] + 128 * d14_3[5]),
-        u8_from_field_unsafe(d14_3[6] + 2 * d14_3[7] + 4 * d14_4[0] + 8 * d14_4[1] + 16 * d14_4[2] + 32 * d14_4[3] + 64 * d14_4[4] + 128 * d14_4[5]),
-        u8_from_field_unsafe(d14_4[6] + 2 * d14_4[7] + 4 * d14_5[0] + 8 * d14_5[1] + 16 * d14_5[2] + 32 * d14_5[3] + 64 * d14_5[4] + 128 * d14_5[5])
-      ];
-      -- b24 = rotl(t21, 2) = byte-rotl 0 + bit-shl 2
-      let d24_0 = u8_bit_decomposition(t21[0]);
-      let d24_1 = u8_bit_decomposition(t21[1]);
-      let d24_2 = u8_bit_decomposition(t21[2]);
-      let d24_3 = u8_bit_decomposition(t21[3]);
-      let d24_4 = u8_bit_decomposition(t21[4]);
-      let d24_5 = u8_bit_decomposition(t21[5]);
-      let d24_6 = u8_bit_decomposition(t21[6]);
-      let d24_7 = u8_bit_decomposition(t21[7]);
-      let b24 = [
-        u8_from_field_unsafe(d24_7[6] + 2 * d24_7[7] + 4 * d24_0[0] + 8 * d24_0[1] + 16 * d24_0[2] + 32 * d24_0[3] + 64 * d24_0[4] + 128 * d24_0[5]),
-        u8_from_field_unsafe(d24_0[6] + 2 * d24_0[7] + 4 * d24_1[0] + 8 * d24_1[1] + 16 * d24_1[2] + 32 * d24_1[3] + 64 * d24_1[4] + 128 * d24_1[5]),
-        u8_from_field_unsafe(d24_1[6] + 2 * d24_1[7] + 4 * d24_2[0] + 8 * d24_2[1] + 16 * d24_2[2] + 32 * d24_2[3] + 64 * d24_2[4] + 128 * d24_2[5]),
-        u8_from_field_unsafe(d24_2[6] + 2 * d24_2[7] + 4 * d24_3[0] + 8 * d24_3[1] + 16 * d24_3[2] + 32 * d24_3[3] + 64 * d24_3[4] + 128 * d24_3[5]),
-        u8_from_field_unsafe(d24_3[6] + 2 * d24_3[7] + 4 * d24_4[0] + 8 * d24_4[1] + 16 * d24_4[2] + 32 * d24_4[3] + 64 * d24_4[4] + 128 * d24_4[5]),
-        u8_from_field_unsafe(d24_4[6] + 2 * d24_4[7] + 4 * d24_5[0] + 8 * d24_5[1] + 16 * d24_5[2] + 32 * d24_5[3] + 64 * d24_5[4] + 128 * d24_5[5]),
-        u8_from_field_unsafe(d24_5[6] + 2 * d24_5[7] + 4 * d24_6[0] + 8 * d24_6[1] + 16 * d24_6[2] + 32 * d24_6[3] + 64 * d24_6[4] + 128 * d24_6[5]),
-        u8_from_field_unsafe(d24_6[6] + 2 * d24_6[7] + 4 * d24_7[0] + 8 * d24_7[1] + 16 * d24_7[2] + 32 * d24_7[3] + 64 * d24_7[4] + 128 * d24_7[5])
-      ];
-      -- b9 = rotl(t22, 61) = byte-rotl 7 + bit-shl 5
-      let d9_0 = u8_bit_decomposition(t22[0]);
-      let d9_1 = u8_bit_decomposition(t22[1]);
-      let d9_2 = u8_bit_decomposition(t22[2]);
-      let d9_3 = u8_bit_decomposition(t22[3]);
-      let d9_4 = u8_bit_decomposition(t22[4]);
-      let d9_5 = u8_bit_decomposition(t22[5]);
-      let d9_6 = u8_bit_decomposition(t22[6]);
-      let d9_7 = u8_bit_decomposition(t22[7]);
-      let b9 = [
-        u8_from_field_unsafe(d9_0[3] + 2 * d9_0[4] + 4 * d9_0[5] + 8 * d9_0[6] + 16 * d9_0[7] + 32 * d9_1[0] + 64 * d9_1[1] + 128 * d9_1[2]),
-        u8_from_field_unsafe(d9_1[3] + 2 * d9_1[4] + 4 * d9_1[5] + 8 * d9_1[6] + 16 * d9_1[7] + 32 * d9_2[0] + 64 * d9_2[1] + 128 * d9_2[2]),
-        u8_from_field_unsafe(d9_2[3] + 2 * d9_2[4] + 4 * d9_2[5] + 8 * d9_2[6] + 16 * d9_2[7] + 32 * d9_3[0] + 64 * d9_3[1] + 128 * d9_3[2]),
-        u8_from_field_unsafe(d9_3[3] + 2 * d9_3[4] + 4 * d9_3[5] + 8 * d9_3[6] + 16 * d9_3[7] + 32 * d9_4[0] + 64 * d9_4[1] + 128 * d9_4[2]),
-        u8_from_field_unsafe(d9_4[3] + 2 * d9_4[4] + 4 * d9_4[5] + 8 * d9_4[6] + 16 * d9_4[7] + 32 * d9_5[0] + 64 * d9_5[1] + 128 * d9_5[2]),
-        u8_from_field_unsafe(d9_5[3] + 2 * d9_5[4] + 4 * d9_5[5] + 8 * d9_5[6] + 16 * d9_5[7] + 32 * d9_6[0] + 64 * d9_6[1] + 128 * d9_6[2]),
-        u8_from_field_unsafe(d9_6[3] + 2 * d9_6[4] + 4 * d9_6[5] + 8 * d9_6[6] + 16 * d9_6[7] + 32 * d9_7[0] + 64 * d9_7[1] + 128 * d9_7[2]),
-        u8_from_field_unsafe(d9_7[3] + 2 * d9_7[4] + 4 * d9_7[5] + 8 * d9_7[6] + 16 * d9_7[7] + 32 * d9_0[0] + 64 * d9_0[1] + 128 * d9_0[2])
-      ];
+      -- b14 = rotl(t20, 18) = byte-rotl 2 + 2x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a14_0_0, c14_0_0) = u8_add(t20[6], t20[6]);
+      let (a14_0_1, c14_0_1) = u8_add(t20[7], t20[7]);
+      let (a14_0_2, c14_0_2) = u8_add(t20[0], t20[0]);
+      let (a14_0_3, c14_0_3) = u8_add(t20[1], t20[1]);
+      let (a14_0_4, c14_0_4) = u8_add(t20[2], t20[2]);
+      let (a14_0_5, c14_0_5) = u8_add(t20[3], t20[3]);
+      let (a14_0_6, c14_0_6) = u8_add(t20[4], t20[4]);
+      let (a14_0_7, c14_0_7) = u8_add(t20[5], t20[5]);
+      let (a14_1_0, c14_1_0) = u8_add(u8_from_field_unsafe(to_field(a14_0_0) + to_field(c14_0_7)), u8_from_field_unsafe(to_field(a14_0_0) + to_field(c14_0_7)));
+      let (a14_1_1, c14_1_1) = u8_add(u8_from_field_unsafe(to_field(a14_0_1) + to_field(c14_0_0)), u8_from_field_unsafe(to_field(a14_0_1) + to_field(c14_0_0)));
+      let (a14_1_2, c14_1_2) = u8_add(u8_from_field_unsafe(to_field(a14_0_2) + to_field(c14_0_1)), u8_from_field_unsafe(to_field(a14_0_2) + to_field(c14_0_1)));
+      let (a14_1_3, c14_1_3) = u8_add(u8_from_field_unsafe(to_field(a14_0_3) + to_field(c14_0_2)), u8_from_field_unsafe(to_field(a14_0_3) + to_field(c14_0_2)));
+      let (a14_1_4, c14_1_4) = u8_add(u8_from_field_unsafe(to_field(a14_0_4) + to_field(c14_0_3)), u8_from_field_unsafe(to_field(a14_0_4) + to_field(c14_0_3)));
+      let (a14_1_5, c14_1_5) = u8_add(u8_from_field_unsafe(to_field(a14_0_5) + to_field(c14_0_4)), u8_from_field_unsafe(to_field(a14_0_5) + to_field(c14_0_4)));
+      let (a14_1_6, c14_1_6) = u8_add(u8_from_field_unsafe(to_field(a14_0_6) + to_field(c14_0_5)), u8_from_field_unsafe(to_field(a14_0_6) + to_field(c14_0_5)));
+      let (a14_1_7, c14_1_7) = u8_add(u8_from_field_unsafe(to_field(a14_0_7) + to_field(c14_0_6)), u8_from_field_unsafe(to_field(a14_0_7) + to_field(c14_0_6)));
+      let b14 = [u8_from_field_unsafe(to_field(a14_1_0) + to_field(c14_1_7)), u8_from_field_unsafe(to_field(a14_1_1) + to_field(c14_1_0)), u8_from_field_unsafe(to_field(a14_1_2) + to_field(c14_1_1)), u8_from_field_unsafe(to_field(a14_1_3) + to_field(c14_1_2)), u8_from_field_unsafe(to_field(a14_1_4) + to_field(c14_1_3)), u8_from_field_unsafe(to_field(a14_1_5) + to_field(c14_1_4)), u8_from_field_unsafe(to_field(a14_1_6) + to_field(c14_1_5)), u8_from_field_unsafe(to_field(a14_1_7) + to_field(c14_1_6))];
+      -- b24 = rotl(t21, 2) = byte-rotl 0 + 2x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a24_0_0, c24_0_0) = u8_add(t21[0], t21[0]);
+      let (a24_0_1, c24_0_1) = u8_add(t21[1], t21[1]);
+      let (a24_0_2, c24_0_2) = u8_add(t21[2], t21[2]);
+      let (a24_0_3, c24_0_3) = u8_add(t21[3], t21[3]);
+      let (a24_0_4, c24_0_4) = u8_add(t21[4], t21[4]);
+      let (a24_0_5, c24_0_5) = u8_add(t21[5], t21[5]);
+      let (a24_0_6, c24_0_6) = u8_add(t21[6], t21[6]);
+      let (a24_0_7, c24_0_7) = u8_add(t21[7], t21[7]);
+      let (a24_1_0, c24_1_0) = u8_add(u8_from_field_unsafe(to_field(a24_0_0) + to_field(c24_0_7)), u8_from_field_unsafe(to_field(a24_0_0) + to_field(c24_0_7)));
+      let (a24_1_1, c24_1_1) = u8_add(u8_from_field_unsafe(to_field(a24_0_1) + to_field(c24_0_0)), u8_from_field_unsafe(to_field(a24_0_1) + to_field(c24_0_0)));
+      let (a24_1_2, c24_1_2) = u8_add(u8_from_field_unsafe(to_field(a24_0_2) + to_field(c24_0_1)), u8_from_field_unsafe(to_field(a24_0_2) + to_field(c24_0_1)));
+      let (a24_1_3, c24_1_3) = u8_add(u8_from_field_unsafe(to_field(a24_0_3) + to_field(c24_0_2)), u8_from_field_unsafe(to_field(a24_0_3) + to_field(c24_0_2)));
+      let (a24_1_4, c24_1_4) = u8_add(u8_from_field_unsafe(to_field(a24_0_4) + to_field(c24_0_3)), u8_from_field_unsafe(to_field(a24_0_4) + to_field(c24_0_3)));
+      let (a24_1_5, c24_1_5) = u8_add(u8_from_field_unsafe(to_field(a24_0_5) + to_field(c24_0_4)), u8_from_field_unsafe(to_field(a24_0_5) + to_field(c24_0_4)));
+      let (a24_1_6, c24_1_6) = u8_add(u8_from_field_unsafe(to_field(a24_0_6) + to_field(c24_0_5)), u8_from_field_unsafe(to_field(a24_0_6) + to_field(c24_0_5)));
+      let (a24_1_7, c24_1_7) = u8_add(u8_from_field_unsafe(to_field(a24_0_7) + to_field(c24_0_6)), u8_from_field_unsafe(to_field(a24_0_7) + to_field(c24_0_6)));
+      let b24 = [u8_from_field_unsafe(to_field(a24_1_0) + to_field(c24_1_7)), u8_from_field_unsafe(to_field(a24_1_1) + to_field(c24_1_0)), u8_from_field_unsafe(to_field(a24_1_2) + to_field(c24_1_1)), u8_from_field_unsafe(to_field(a24_1_3) + to_field(c24_1_2)), u8_from_field_unsafe(to_field(a24_1_4) + to_field(c24_1_3)), u8_from_field_unsafe(to_field(a24_1_5) + to_field(c24_1_4)), u8_from_field_unsafe(to_field(a24_1_6) + to_field(c24_1_5)), u8_from_field_unsafe(to_field(a24_1_7) + to_field(c24_1_6))];
+      -- b9 = rotl(t22, 61) = byte-rotl 8 + 3x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h9_0_0 = u8_shift_right(t22[0]);
+      let h9_0_1 = u8_shift_right(t22[1]);
+      let h9_0_2 = u8_shift_right(t22[2]);
+      let h9_0_3 = u8_shift_right(t22[3]);
+      let h9_0_4 = u8_shift_right(t22[4]);
+      let h9_0_5 = u8_shift_right(t22[5]);
+      let h9_0_6 = u8_shift_right(t22[6]);
+      let h9_0_7 = u8_shift_right(t22[7]);
+      let h9_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0) + 128 * (to_field(t22[1]) - 2 * to_field(h9_0_1))));
+      let h9_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1) + 128 * (to_field(t22[2]) - 2 * to_field(h9_0_2))));
+      let h9_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_2) + 128 * (to_field(t22[3]) - 2 * to_field(h9_0_3))));
+      let h9_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_3) + 128 * (to_field(t22[4]) - 2 * to_field(h9_0_4))));
+      let h9_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_4) + 128 * (to_field(t22[5]) - 2 * to_field(h9_0_5))));
+      let h9_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_5) + 128 * (to_field(t22[6]) - 2 * to_field(h9_0_6))));
+      let h9_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_6) + 128 * (to_field(t22[7]) - 2 * to_field(h9_0_7))));
+      let h9_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_7) + 128 * (to_field(t22[0]) - 2 * to_field(h9_0_0))));
+      let h9_2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1) + 128 * (to_field(t22[2]) - 2 * to_field(h9_0_2)))) - 2 * to_field(h9_1_1))));
+      let h9_2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_2) + 128 * (to_field(t22[3]) - 2 * to_field(h9_0_3)))) - 2 * to_field(h9_1_2))));
+      let h9_2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_3) + 128 * (to_field(t22[4]) - 2 * to_field(h9_0_4)))) - 2 * to_field(h9_1_3))));
+      let h9_2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_4) + 128 * (to_field(t22[5]) - 2 * to_field(h9_0_5)))) - 2 * to_field(h9_1_4))));
+      let h9_2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_5) + 128 * (to_field(t22[6]) - 2 * to_field(h9_0_6)))) - 2 * to_field(h9_1_5))));
+      let h9_2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_6) + 128 * (to_field(t22[7]) - 2 * to_field(h9_0_7)))) - 2 * to_field(h9_1_6))));
+      let h9_2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_7) + 128 * (to_field(t22[0]) - 2 * to_field(h9_0_0)))) - 2 * to_field(h9_1_7))));
+      let h9_2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0) + 128 * (to_field(t22[1]) - 2 * to_field(h9_0_1)))) - 2 * to_field(h9_1_0))));
+      let b9 = [u8_from_field_unsafe(to_field(h9_2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_2) + 128 * (to_field(t22[3]) - 2 * to_field(h9_0_3)))) - 2 * to_field(h9_1_2)))) - 2 * to_field(h9_2_1))), u8_from_field_unsafe(to_field(h9_2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_3) + 128 * (to_field(t22[4]) - 2 * to_field(h9_0_4)))) - 2 * to_field(h9_1_3)))) - 2 * to_field(h9_2_2))), u8_from_field_unsafe(to_field(h9_2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_4) + 128 * (to_field(t22[5]) - 2 * to_field(h9_0_5)))) - 2 * to_field(h9_1_4)))) - 2 * to_field(h9_2_3))), u8_from_field_unsafe(to_field(h9_2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_5) + 128 * (to_field(t22[6]) - 2 * to_field(h9_0_6)))) - 2 * to_field(h9_1_5)))) - 2 * to_field(h9_2_4))), u8_from_field_unsafe(to_field(h9_2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_6) + 128 * (to_field(t22[7]) - 2 * to_field(h9_0_7)))) - 2 * to_field(h9_1_6)))) - 2 * to_field(h9_2_5))), u8_from_field_unsafe(to_field(h9_2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_7) + 128 * (to_field(t22[0]) - 2 * to_field(h9_0_0)))) - 2 * to_field(h9_1_7)))) - 2 * to_field(h9_2_6))), u8_from_field_unsafe(to_field(h9_2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0) + 128 * (to_field(t22[1]) - 2 * to_field(h9_0_1)))) - 2 * to_field(h9_1_0)))) - 2 * to_field(h9_2_7))), u8_from_field_unsafe(to_field(h9_2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1) + 128 * (to_field(t22[2]) - 2 * to_field(h9_0_2)))) - 2 * to_field(h9_1_1)))) - 2 * to_field(h9_2_0)))];
       -- b19 = rotl(t23, 56): byte rotation only (free)
       let b19 = [t23[1], t23[2], t23[3], t23[4], t23[5], t23[6], t23[7], t23[0]];
-      -- b4 = rotl(t24, 14) = byte-rotl 1 + bit-shl 6
-      let d4_0 = u8_bit_decomposition(t24[0]);
-      let d4_1 = u8_bit_decomposition(t24[1]);
-      let d4_2 = u8_bit_decomposition(t24[2]);
-      let d4_3 = u8_bit_decomposition(t24[3]);
-      let d4_4 = u8_bit_decomposition(t24[4]);
-      let d4_5 = u8_bit_decomposition(t24[5]);
-      let d4_6 = u8_bit_decomposition(t24[6]);
-      let d4_7 = u8_bit_decomposition(t24[7]);
-      let b4 = [
-        u8_from_field_unsafe(d4_6[2] + 2 * d4_6[3] + 4 * d4_6[4] + 8 * d4_6[5] + 16 * d4_6[6] + 32 * d4_6[7] + 64 * d4_7[0] + 128 * d4_7[1]),
-        u8_from_field_unsafe(d4_7[2] + 2 * d4_7[3] + 4 * d4_7[4] + 8 * d4_7[5] + 16 * d4_7[6] + 32 * d4_7[7] + 64 * d4_0[0] + 128 * d4_0[1]),
-        u8_from_field_unsafe(d4_0[2] + 2 * d4_0[3] + 4 * d4_0[4] + 8 * d4_0[5] + 16 * d4_0[6] + 32 * d4_0[7] + 64 * d4_1[0] + 128 * d4_1[1]),
-        u8_from_field_unsafe(d4_1[2] + 2 * d4_1[3] + 4 * d4_1[4] + 8 * d4_1[5] + 16 * d4_1[6] + 32 * d4_1[7] + 64 * d4_2[0] + 128 * d4_2[1]),
-        u8_from_field_unsafe(d4_2[2] + 2 * d4_2[3] + 4 * d4_2[4] + 8 * d4_2[5] + 16 * d4_2[6] + 32 * d4_2[7] + 64 * d4_3[0] + 128 * d4_3[1]),
-        u8_from_field_unsafe(d4_3[2] + 2 * d4_3[3] + 4 * d4_3[4] + 8 * d4_3[5] + 16 * d4_3[6] + 32 * d4_3[7] + 64 * d4_4[0] + 128 * d4_4[1]),
-        u8_from_field_unsafe(d4_4[2] + 2 * d4_4[3] + 4 * d4_4[4] + 8 * d4_4[5] + 16 * d4_4[6] + 32 * d4_4[7] + 64 * d4_5[0] + 128 * d4_5[1]),
-        u8_from_field_unsafe(d4_5[2] + 2 * d4_5[3] + 4 * d4_5[4] + 8 * d4_5[5] + 16 * d4_5[6] + 32 * d4_5[7] + 64 * d4_6[0] + 128 * d4_6[1])
-      ];
+      -- b4 = rotl(t24, 14) = byte-rotl 2 + 2x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h4_0_0 = u8_shift_right(t24[6]);
+      let h4_0_1 = u8_shift_right(t24[7]);
+      let h4_0_2 = u8_shift_right(t24[0]);
+      let h4_0_3 = u8_shift_right(t24[1]);
+      let h4_0_4 = u8_shift_right(t24[2]);
+      let h4_0_5 = u8_shift_right(t24[3]);
+      let h4_0_6 = u8_shift_right(t24[4]);
+      let h4_0_7 = u8_shift_right(t24[5]);
+      let h4_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0) + 128 * (to_field(t24[7]) - 2 * to_field(h4_0_1))));
+      let h4_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_1) + 128 * (to_field(t24[0]) - 2 * to_field(h4_0_2))));
+      let h4_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_2) + 128 * (to_field(t24[1]) - 2 * to_field(h4_0_3))));
+      let h4_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_3) + 128 * (to_field(t24[2]) - 2 * to_field(h4_0_4))));
+      let h4_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_4) + 128 * (to_field(t24[3]) - 2 * to_field(h4_0_5))));
+      let h4_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_5) + 128 * (to_field(t24[4]) - 2 * to_field(h4_0_6))));
+      let h4_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_6) + 128 * (to_field(t24[5]) - 2 * to_field(h4_0_7))));
+      let h4_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_7) + 128 * (to_field(t24[6]) - 2 * to_field(h4_0_0))));
+      let b4 = [u8_from_field_unsafe(to_field(h4_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_1) + 128 * (to_field(t24[0]) - 2 * to_field(h4_0_2)))) - 2 * to_field(h4_1_1))), u8_from_field_unsafe(to_field(h4_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_2) + 128 * (to_field(t24[1]) - 2 * to_field(h4_0_3)))) - 2 * to_field(h4_1_2))), u8_from_field_unsafe(to_field(h4_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_3) + 128 * (to_field(t24[2]) - 2 * to_field(h4_0_4)))) - 2 * to_field(h4_1_3))), u8_from_field_unsafe(to_field(h4_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_4) + 128 * (to_field(t24[3]) - 2 * to_field(h4_0_5)))) - 2 * to_field(h4_1_4))), u8_from_field_unsafe(to_field(h4_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_5) + 128 * (to_field(t24[4]) - 2 * to_field(h4_0_6)))) - 2 * to_field(h4_1_5))), u8_from_field_unsafe(to_field(h4_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_6) + 128 * (to_field(t24[5]) - 2 * to_field(h4_0_7)))) - 2 * to_field(h4_1_6))), u8_from_field_unsafe(to_field(h4_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_7) + 128 * (to_field(t24[6]) - 2 * to_field(h4_0_0)))) - 2 * to_field(h4_1_7))), u8_from_field_unsafe(to_field(h4_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0) + 128 * (to_field(t24[7]) - 2 * to_field(h4_0_1)))) - 2 * to_field(h4_1_0)))];
       -- chi: e[x,y] = b[x,y] ^ (~b[x+1,y] & b[x+2,y]); NOT is the free
       -- recomposition 255 - b.
       let e0 = [u8_xor(b0[0], u8_and(u8_from_field_unsafe(255 - to_field(b1[0])), b2[0])), u8_xor(b0[1], u8_and(u8_from_field_unsafe(255 - to_field(b1[1])), b2[1])), u8_xor(b0[2], u8_and(u8_from_field_unsafe(255 - to_field(b1[2])), b2[2])), u8_xor(b0[3], u8_and(u8_from_field_unsafe(255 - to_field(b1[3])), b2[3])), u8_xor(b0[4], u8_and(u8_from_field_unsafe(255 - to_field(b1[4])), b2[4])), u8_xor(b0[5], u8_and(u8_from_field_unsafe(255 - to_field(b1[5])), b2[5])), u8_xor(b0[6], u8_and(u8_from_field_unsafe(255 - to_field(b1[6])), b2[6])), u8_xor(b0[7], u8_and(u8_from_field_unsafe(255 - to_field(b1[7])), b2[7]))];

From 57045eaff7ad5791a71574faa717d0c8e8193761 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sat, 11 Jul 2026 08:27:40 -0700
Subject: [PATCH 11/22] Aiur keccak: absorb the rate block directly from the
 stream
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

read_block copied each 136-byte rate block into an intermediate linked
list (136 stores/block), which rate_lane then re-walked with list_drop
per lane — pure memory traffic (read_block 545k + list_drop 409k +
rate_lane 112k + half of memory[3] FFT). Replace with take_byte, which
reads the stream directly and injects pad10*1 inline when the message
is exhausted (no store on the real-byte path), pulled 8 at a time by
take_lane. The pad flag `first_pad` threads through the walk; a block
recurses only if 136 real bytes were consumed, so it also decides the
extra all-padding block for message lengths that are a multiple of 136.

take_lane is a factored circuit rather than 136 inline take_byte lets:
the whole toplevel elaborates as one Source.Toplevel AST, and inlining
the walk overflows the elaborator.

Probe (1 hash, 2048 bytes, non-periodic LCG): 16,206,377 ->
15,292,607 (-5.6%); memory[3] rows 4224 -> 2049. `aiur-hashes` keccak
cases green (rate boundaries + prove/verify) against the Rust oracle.
---
 Ix/IxVM/Keccak.lean | 118 +++++++++++++++++++-------------------------
 1 file changed, 52 insertions(+), 66 deletions(-)

diff --git a/Ix/IxVM/Keccak.lean b/Ix/IxVM/Keccak.lean
index 063bef59..d80165ff 100644
--- a/Ix/IxVM/Keccak.lean
+++ b/Ix/IxVM/Keccak.lean
@@ -51,67 +51,59 @@ def keccak := ⟦
 
   /- # Sponge -/
 
-  -- Pad bytes for positions i..135 once the message is exhausted: `first`
-  -- is 1 on the first pad position (0x01 bit), position 135 carries the
-  -- 0x80 bit (0x81 when both land on 135).
-  fn build_pad(i: G, first: G) -> ByteStream {
-    match 136 - i {
-      0 => store(ListNode.Nil),
-      _ =>
-        store(ListNode.Cons(u8_from_field_unsafe(first + 128 * eq_zero(135 - i)),
-                            build_pad(i + 1, 0))),
+  -- Pull one rate byte from the stream, injecting pad10*1 when the
+  -- message is exhausted. `first_pad` is 1 until the first pad byte is
+  -- emitted (which carries the 0x01 bit); position 135 carries 0x80
+  -- (0x81 when both coincide). No store on the real-byte path — the
+  -- block is consumed directly, not copied into a 136-node list.
+  fn take_byte(stream: ByteStream, pos: G, first_pad: G) -> (U8, ByteStream, G) {
+    match load(stream) {
+      ListNode.Cons(b, rest) => (b, rest, first_pad),
+      ListNode.Nil =>
+        (u8_from_field_unsafe(first_pad + 128 * eq_zero(135 - pos)),
+         store(ListNode.Nil), 0),
     }
   }
 
-  -- Take one 136-byte rate block from `stream` starting at position `i`.
-  -- Returns (block, rest, full): full=1 iff 136 message bytes were consumed
-  -- (padding not yet applied). An empty stream yields the all-padding block
-  -- keccak appends when the message length is a multiple of 136.
-  fn read_block(stream: ByteStream, i: G) -> (ByteStream, ByteStream, G) {
-    match 136 - i {
-      0 => (store(ListNode.Nil), stream, 1),
-      _ => match load(stream) {
-        ListNode.Cons(b, rest) =>
-          let (blk, r, f) = read_block(rest, i + 1);
-          (store(ListNode.Cons(b, blk)), r, f),
-        ListNode.Nil => (build_pad(i, 1), store(ListNode.Nil), 0),
-      },
-    }
-  }
-
-  -- Extract lane bytes [b .. b+7] from the rate block (one `list_drop` to
-  -- the first byte; the rest are successive tails).
-  fn rate_lane(rate: ByteStream, b: G) -> [U8; 8] {
-    let &ListNode.Cons(r0, t0) = list_drop(rate, b);
-    let &ListNode.Cons(r1, t1) = t0;
-    let &ListNode.Cons(r2, t2) = t1;
-    let &ListNode.Cons(r3, t3) = t2;
-    let &ListNode.Cons(r4, t4) = t3;
-    let &ListNode.Cons(r5, t5) = t4;
-    let &ListNode.Cons(r6, t6) = t5;
-    let &ListNode.Cons(r7, _) = t6;
-    [r0, r1, r2, r3, r4, r5, r6, r7]
+  -- Pull 8 consecutive rate bytes (one lane) from the stream, threading
+  -- position and the pad flag. Factored out of absorb_blocks so the
+  -- 136-byte walk is one reused circuit, not 136 inline lets in the
+  -- toplevel AST (which overflows the elaborator).
+  fn take_lane(stream: ByteStream, pos: G, first_pad: G) -> ([U8; 8], ByteStream, G) {
+    let (b0, st, fp) = take_byte(stream, pos, first_pad);
+    let (b1, st, fp) = take_byte(st, pos + 1, fp);
+    let (b2, st, fp) = take_byte(st, pos + 2, fp);
+    let (b3, st, fp) = take_byte(st, pos + 3, fp);
+    let (b4, st, fp) = take_byte(st, pos + 4, fp);
+    let (b5, st, fp) = take_byte(st, pos + 5, fp);
+    let (b6, st, fp) = take_byte(st, pos + 6, fp);
+    let (b7, st, fp) = take_byte(st, pos + 7, fp);
+    ([b0, b1, b2, b3, b4, b5, b6, b7], st, fp)
   }
 
-  -- XOR one 136-byte rate block into the first 17 lanes, then permute.
-  fn absorb_one(s: [[U8; 8]; 25], rate: ByteStream) -> [[U8; 8]; 25] {
-    let rl0 = rate_lane(rate, 0);
-    let rl1 = rate_lane(rate, 8);
-    let rl2 = rate_lane(rate, 16);
-    let rl3 = rate_lane(rate, 24);
-    let rl4 = rate_lane(rate, 32);
-    let rl5 = rate_lane(rate, 40);
-    let rl6 = rate_lane(rate, 48);
-    let rl7 = rate_lane(rate, 56);
-    let rl8 = rate_lane(rate, 64);
-    let rl9 = rate_lane(rate, 72);
-    let rl10 = rate_lane(rate, 80);
-    let rl11 = rate_lane(rate, 88);
-    let rl12 = rate_lane(rate, 96);
-    let rl13 = rate_lane(rate, 104);
-    let rl14 = rate_lane(rate, 112);
-    let rl15 = rate_lane(rate, 120);
-    let rl16 = rate_lane(rate, 128);
+  -- Absorb one 136-byte rate block (17 lanes) directly from the stream
+  -- into the state, permute, and recurse while whole real blocks keep
+  -- filling (first_pad still 1 after 136 bytes). `first_pad` resets to 1
+  -- per block: only a fully-real block recurses, so a fresh block never
+  -- starts mid-pad.
+  fn absorb_blocks(stream: ByteStream, s: [[U8; 8]; 25]) -> [[U8; 8]; 25] {
+    let (rl0, st, fp) = take_lane(stream, 0, 1);
+    let (rl1, st, fp) = take_lane(st, 8, fp);
+    let (rl2, st, fp) = take_lane(st, 16, fp);
+    let (rl3, st, fp) = take_lane(st, 24, fp);
+    let (rl4, st, fp) = take_lane(st, 32, fp);
+    let (rl5, st, fp) = take_lane(st, 40, fp);
+    let (rl6, st, fp) = take_lane(st, 48, fp);
+    let (rl7, st, fp) = take_lane(st, 56, fp);
+    let (rl8, st, fp) = take_lane(st, 64, fp);
+    let (rl9, st, fp) = take_lane(st, 72, fp);
+    let (rl10, st, fp) = take_lane(st, 80, fp);
+    let (rl11, st, fp) = take_lane(st, 88, fp);
+    let (rl12, st, fp) = take_lane(st, 96, fp);
+    let (rl13, st, fp) = take_lane(st, 104, fp);
+    let (rl14, st, fp) = take_lane(st, 112, fp);
+    let (rl15, st, fp) = take_lane(st, 120, fp);
+    let (rl16, st, fp) = take_lane(st, 128, fp);
     let s = set(s, 0, [u8_xor(s[0][0], rl0[0]), u8_xor(s[0][1], rl0[1]), u8_xor(s[0][2], rl0[2]), u8_xor(s[0][3], rl0[3]), u8_xor(s[0][4], rl0[4]), u8_xor(s[0][5], rl0[5]), u8_xor(s[0][6], rl0[6]), u8_xor(s[0][7], rl0[7])]);
     let s = set(s, 1, [u8_xor(s[1][0], rl1[0]), u8_xor(s[1][1], rl1[1]), u8_xor(s[1][2], rl1[2]), u8_xor(s[1][3], rl1[3]), u8_xor(s[1][4], rl1[4]), u8_xor(s[1][5], rl1[5]), u8_xor(s[1][6], rl1[6]), u8_xor(s[1][7], rl1[7])]);
     let s = set(s, 2, [u8_xor(s[2][0], rl2[0]), u8_xor(s[2][1], rl2[1]), u8_xor(s[2][2], rl2[2]), u8_xor(s[2][3], rl2[3]), u8_xor(s[2][4], rl2[4]), u8_xor(s[2][5], rl2[5]), u8_xor(s[2][6], rl2[6]), u8_xor(s[2][7], rl2[7])]);
@@ -129,16 +121,10 @@ def keccak := ⟦
     let s = set(s, 14, [u8_xor(s[14][0], rl14[0]), u8_xor(s[14][1], rl14[1]), u8_xor(s[14][2], rl14[2]), u8_xor(s[14][3], rl14[3]), u8_xor(s[14][4], rl14[4]), u8_xor(s[14][5], rl14[5]), u8_xor(s[14][6], rl14[6]), u8_xor(s[14][7], rl14[7])]);
     let s = set(s, 15, [u8_xor(s[15][0], rl15[0]), u8_xor(s[15][1], rl15[1]), u8_xor(s[15][2], rl15[2]), u8_xor(s[15][3], rl15[3]), u8_xor(s[15][4], rl15[4]), u8_xor(s[15][5], rl15[5]), u8_xor(s[15][6], rl15[6]), u8_xor(s[15][7], rl15[7])]);
     let s = set(s, 16, [u8_xor(s[16][0], rl16[0]), u8_xor(s[16][1], rl16[1]), u8_xor(s[16][2], rl16[2]), u8_xor(s[16][3], rl16[3]), u8_xor(s[16][4], rl16[4]), u8_xor(s[16][5], rl16[5]), u8_xor(s[16][6], rl16[6]), u8_xor(s[16][7], rl16[7])]);
-    keccak_f(s)
-  }
-
-  -- Absorb every rate block of the (padded) message into the state.
-  fn absorb_blocks(stream: ByteStream, s: [[U8; 8]; 25]) -> [[U8; 8]; 25] {
-    let (block, rest, full) = read_block(stream, 0);
-    let s2 = absorb_one(s, block);
-    match full {
-      0 => s2,
-      _ => absorb_blocks(rest, s2),
+    let s2 = keccak_f(s);
+    match fp {
+      1 => absorb_blocks(st, s2),
+      _ => s2,
     }
   }
 

From b66f6dd041a94a90c6842def6018d4a7cf996eb1 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sat, 11 Jul 2026 08:58:57 -0700
Subject: [PATCH 12/22] Aiur keccak: merge the round into one circuit; keccak_f
 bakes RC literals
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The round ran as two circuits (theta | rho+pi+chi+iota) because one
full round overflowed the elaborator when unrolled. The cheap
rotations shrank rho enough that a single merged round now fits, so
keccak_roundN does the whole permutation round in one circuit: keccak_f
calls it 24x (per permutation) instead of calling two half-circuits
48x, halving the state-rematerialization interface (keccak_f width
9902 -> 5054) and giving the merged circuit one shared column layout
instead of two.

keccak_f now bakes the 24 round constants as literal lane arguments
(no RC array + no fold index), which also drops the RC-array column
traffic. keccak_roundN is emitted with per-round name suffixes so it
can hold N rounds; N=2 already overflows the elaborator, so it stays
at one round per circuit (height 384). Inlining all 24 rounds into one
height-16 circuit — the remaining ~2x — needs the round AST built
programmatically instead of through the quasiquote macro.

Probe (1 hash, 2048 bytes, non-periodic LCG): 15,292,607 ->
14,303,230 (-6.5%). `aiur-hashes` keccak cases green (rate boundaries
+ prove/verify) against the Rust oracle.
---
 Ix/IxVM/Keccak.lean | 1103 ++++++++++++++++++++-----------------------
 1 file changed, 508 insertions(+), 595 deletions(-)

diff --git a/Ix/IxVM/Keccak.lean b/Ix/IxVM/Keccak.lean
index d80165ff..1fe57799 100644
--- a/Ix/IxVM/Keccak.lean
+++ b/Ix/IxVM/Keccak.lean
@@ -134,605 +134,518 @@ def keccak := ⟦
     [s[0], s[1], s[2], s[3]]
   }
 
-  /- # keccak-f[1600]: 24 unrolled rounds of theta-rho-pi-chi-iota -/
+  /- # keccak-f[1600]: 24 rounds of theta-rho-pi-chi-iota, 1 per keccak_roundN circuit (height = 384/1) -/
 
   fn keccak_f(s: [[U8; 8]; 25]) -> [[U8; 8]; 25] {
-    let RC = [
-      [0x01u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-      [0x82u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-      [0x8au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
-      [0u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8],
-      [0x8bu8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-      [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8],
-      [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8],
-      [0x09u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
-      [0x8au8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-      [0x88u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-      [0x09u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8],
-      [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8],
-      [0x8bu8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8],
-      [0x8bu8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
-      [0x89u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
-      [0x03u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
-      [0x02u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
-      [0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
-      [0x0au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-      [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8],
-      [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8],
-      [0x80u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8],
-      [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8],
-      [0x08u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]
-    ];
-    fold(0 .. 24, s, |s, @i| keccak_rho_chi_iota(keccak_theta(s), RC[@i]))
+    let s = keccak_roundN(s, [0x01u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_roundN(s, [0x82u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_roundN(s, [0x8au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_roundN(s, [0u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_roundN(s, [0x8bu8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_roundN(s, [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_roundN(s, [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_roundN(s, [0x09u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_roundN(s, [0x8au8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_roundN(s, [0x88u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_roundN(s, [0x09u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_roundN(s, [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_roundN(s, [0x8bu8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_roundN(s, [0x8bu8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_roundN(s, [0x89u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_roundN(s, [0x03u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_roundN(s, [0x02u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_roundN(s, [0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_roundN(s, [0x0au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_roundN(s, [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_roundN(s, [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_roundN(s, [0x80u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_roundN(s, [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    keccak_roundN(s, [0x08u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8])
   }
 
-  -- One round, split into two circuits (theta | rho+pi+chi+iota), each of
-  -- height 24 x permutations. A single fully-unrolled permutation circuit
-  -- would be cheaper (no 200-column state re-input or 200 output aux per
-  -- call, one row per permutation at a 24x shorter height's log2), but its
-  -- ~7300-let macro-expanded body overflows the Lean elaborator's stack.
-  -- Building the Source.Term programmatically would unlock it.
-  fn keccak_theta(s: [[U8; 8]; 25]) -> [[U8; 8]; 25] {
-      -- theta: column parities C[x] = xor of the 5 lanes in column x.
-      let c0 = [
-        u8_xor(s[20][0], u8_xor(s[15][0], u8_xor(s[10][0], u8_xor(s[5][0], s[0][0])))),
-        u8_xor(s[20][1], u8_xor(s[15][1], u8_xor(s[10][1], u8_xor(s[5][1], s[0][1])))),
-        u8_xor(s[20][2], u8_xor(s[15][2], u8_xor(s[10][2], u8_xor(s[5][2], s[0][2])))),
-        u8_xor(s[20][3], u8_xor(s[15][3], u8_xor(s[10][3], u8_xor(s[5][3], s[0][3])))),
-        u8_xor(s[20][4], u8_xor(s[15][4], u8_xor(s[10][4], u8_xor(s[5][4], s[0][4])))),
-        u8_xor(s[20][5], u8_xor(s[15][5], u8_xor(s[10][5], u8_xor(s[5][5], s[0][5])))),
-        u8_xor(s[20][6], u8_xor(s[15][6], u8_xor(s[10][6], u8_xor(s[5][6], s[0][6])))),
-        u8_xor(s[20][7], u8_xor(s[15][7], u8_xor(s[10][7], u8_xor(s[5][7], s[0][7]))))
-      ];
-      let c1 = [
-        u8_xor(s[21][0], u8_xor(s[16][0], u8_xor(s[11][0], u8_xor(s[6][0], s[1][0])))),
-        u8_xor(s[21][1], u8_xor(s[16][1], u8_xor(s[11][1], u8_xor(s[6][1], s[1][1])))),
-        u8_xor(s[21][2], u8_xor(s[16][2], u8_xor(s[11][2], u8_xor(s[6][2], s[1][2])))),
-        u8_xor(s[21][3], u8_xor(s[16][3], u8_xor(s[11][3], u8_xor(s[6][3], s[1][3])))),
-        u8_xor(s[21][4], u8_xor(s[16][4], u8_xor(s[11][4], u8_xor(s[6][4], s[1][4])))),
-        u8_xor(s[21][5], u8_xor(s[16][5], u8_xor(s[11][5], u8_xor(s[6][5], s[1][5])))),
-        u8_xor(s[21][6], u8_xor(s[16][6], u8_xor(s[11][6], u8_xor(s[6][6], s[1][6])))),
-        u8_xor(s[21][7], u8_xor(s[16][7], u8_xor(s[11][7], u8_xor(s[6][7], s[1][7]))))
-      ];
-      let c2 = [
-        u8_xor(s[22][0], u8_xor(s[17][0], u8_xor(s[12][0], u8_xor(s[7][0], s[2][0])))),
-        u8_xor(s[22][1], u8_xor(s[17][1], u8_xor(s[12][1], u8_xor(s[7][1], s[2][1])))),
-        u8_xor(s[22][2], u8_xor(s[17][2], u8_xor(s[12][2], u8_xor(s[7][2], s[2][2])))),
-        u8_xor(s[22][3], u8_xor(s[17][3], u8_xor(s[12][3], u8_xor(s[7][3], s[2][3])))),
-        u8_xor(s[22][4], u8_xor(s[17][4], u8_xor(s[12][4], u8_xor(s[7][4], s[2][4])))),
-        u8_xor(s[22][5], u8_xor(s[17][5], u8_xor(s[12][5], u8_xor(s[7][5], s[2][5])))),
-        u8_xor(s[22][6], u8_xor(s[17][6], u8_xor(s[12][6], u8_xor(s[7][6], s[2][6])))),
-        u8_xor(s[22][7], u8_xor(s[17][7], u8_xor(s[12][7], u8_xor(s[7][7], s[2][7]))))
-      ];
-      let c3 = [
-        u8_xor(s[23][0], u8_xor(s[18][0], u8_xor(s[13][0], u8_xor(s[8][0], s[3][0])))),
-        u8_xor(s[23][1], u8_xor(s[18][1], u8_xor(s[13][1], u8_xor(s[8][1], s[3][1])))),
-        u8_xor(s[23][2], u8_xor(s[18][2], u8_xor(s[13][2], u8_xor(s[8][2], s[3][2])))),
-        u8_xor(s[23][3], u8_xor(s[18][3], u8_xor(s[13][3], u8_xor(s[8][3], s[3][3])))),
-        u8_xor(s[23][4], u8_xor(s[18][4], u8_xor(s[13][4], u8_xor(s[8][4], s[3][4])))),
-        u8_xor(s[23][5], u8_xor(s[18][5], u8_xor(s[13][5], u8_xor(s[8][5], s[3][5])))),
-        u8_xor(s[23][6], u8_xor(s[18][6], u8_xor(s[13][6], u8_xor(s[8][6], s[3][6])))),
-        u8_xor(s[23][7], u8_xor(s[18][7], u8_xor(s[13][7], u8_xor(s[8][7], s[3][7]))))
-      ];
-      let c4 = [
-        u8_xor(s[24][0], u8_xor(s[19][0], u8_xor(s[14][0], u8_xor(s[9][0], s[4][0])))),
-        u8_xor(s[24][1], u8_xor(s[19][1], u8_xor(s[14][1], u8_xor(s[9][1], s[4][1])))),
-        u8_xor(s[24][2], u8_xor(s[19][2], u8_xor(s[14][2], u8_xor(s[9][2], s[4][2])))),
-        u8_xor(s[24][3], u8_xor(s[19][3], u8_xor(s[14][3], u8_xor(s[9][3], s[4][3])))),
-        u8_xor(s[24][4], u8_xor(s[19][4], u8_xor(s[14][4], u8_xor(s[9][4], s[4][4])))),
-        u8_xor(s[24][5], u8_xor(s[19][5], u8_xor(s[14][5], u8_xor(s[9][5], s[4][5])))),
-        u8_xor(s[24][6], u8_xor(s[19][6], u8_xor(s[14][6], u8_xor(s[9][6], s[4][6])))),
-        u8_xor(s[24][7], u8_xor(s[19][7], u8_xor(s[14][7], u8_xor(s[9][7], s[4][7]))))
-      ];
-      -- rotl-by-1 of each C lane via the u8_add trick: (b + b) yields
-      -- (2b mod 256, msb); the even low byte absorbs the neighbor byte's
-      -- msb with a free field add.
-      let (l0_0, m0_0) = u8_add(c0[0], c0[0]);
-      let (l0_1, m0_1) = u8_add(c0[1], c0[1]);
-      let (l0_2, m0_2) = u8_add(c0[2], c0[2]);
-      let (l0_3, m0_3) = u8_add(c0[3], c0[3]);
-      let (l0_4, m0_4) = u8_add(c0[4], c0[4]);
-      let (l0_5, m0_5) = u8_add(c0[5], c0[5]);
-      let (l0_6, m0_6) = u8_add(c0[6], c0[6]);
-      let (l0_7, m0_7) = u8_add(c0[7], c0[7]);
-      let r0 = [u8_from_field_unsafe(to_field(l0_0) + to_field(m0_7)), u8_from_field_unsafe(to_field(l0_1) + to_field(m0_0)), u8_from_field_unsafe(to_field(l0_2) + to_field(m0_1)), u8_from_field_unsafe(to_field(l0_3) + to_field(m0_2)), u8_from_field_unsafe(to_field(l0_4) + to_field(m0_3)), u8_from_field_unsafe(to_field(l0_5) + to_field(m0_4)), u8_from_field_unsafe(to_field(l0_6) + to_field(m0_5)), u8_from_field_unsafe(to_field(l0_7) + to_field(m0_6))];
-      let (l1_0, m1_0) = u8_add(c1[0], c1[0]);
-      let (l1_1, m1_1) = u8_add(c1[1], c1[1]);
-      let (l1_2, m1_2) = u8_add(c1[2], c1[2]);
-      let (l1_3, m1_3) = u8_add(c1[3], c1[3]);
-      let (l1_4, m1_4) = u8_add(c1[4], c1[4]);
-      let (l1_5, m1_5) = u8_add(c1[5], c1[5]);
-      let (l1_6, m1_6) = u8_add(c1[6], c1[6]);
-      let (l1_7, m1_7) = u8_add(c1[7], c1[7]);
-      let r1 = [u8_from_field_unsafe(to_field(l1_0) + to_field(m1_7)), u8_from_field_unsafe(to_field(l1_1) + to_field(m1_0)), u8_from_field_unsafe(to_field(l1_2) + to_field(m1_1)), u8_from_field_unsafe(to_field(l1_3) + to_field(m1_2)), u8_from_field_unsafe(to_field(l1_4) + to_field(m1_3)), u8_from_field_unsafe(to_field(l1_5) + to_field(m1_4)), u8_from_field_unsafe(to_field(l1_6) + to_field(m1_5)), u8_from_field_unsafe(to_field(l1_7) + to_field(m1_6))];
-      let (l2_0, m2_0) = u8_add(c2[0], c2[0]);
-      let (l2_1, m2_1) = u8_add(c2[1], c2[1]);
-      let (l2_2, m2_2) = u8_add(c2[2], c2[2]);
-      let (l2_3, m2_3) = u8_add(c2[3], c2[3]);
-      let (l2_4, m2_4) = u8_add(c2[4], c2[4]);
-      let (l2_5, m2_5) = u8_add(c2[5], c2[5]);
-      let (l2_6, m2_6) = u8_add(c2[6], c2[6]);
-      let (l2_7, m2_7) = u8_add(c2[7], c2[7]);
-      let r2 = [u8_from_field_unsafe(to_field(l2_0) + to_field(m2_7)), u8_from_field_unsafe(to_field(l2_1) + to_field(m2_0)), u8_from_field_unsafe(to_field(l2_2) + to_field(m2_1)), u8_from_field_unsafe(to_field(l2_3) + to_field(m2_2)), u8_from_field_unsafe(to_field(l2_4) + to_field(m2_3)), u8_from_field_unsafe(to_field(l2_5) + to_field(m2_4)), u8_from_field_unsafe(to_field(l2_6) + to_field(m2_5)), u8_from_field_unsafe(to_field(l2_7) + to_field(m2_6))];
-      let (l3_0, m3_0) = u8_add(c3[0], c3[0]);
-      let (l3_1, m3_1) = u8_add(c3[1], c3[1]);
-      let (l3_2, m3_2) = u8_add(c3[2], c3[2]);
-      let (l3_3, m3_3) = u8_add(c3[3], c3[3]);
-      let (l3_4, m3_4) = u8_add(c3[4], c3[4]);
-      let (l3_5, m3_5) = u8_add(c3[5], c3[5]);
-      let (l3_6, m3_6) = u8_add(c3[6], c3[6]);
-      let (l3_7, m3_7) = u8_add(c3[7], c3[7]);
-      let r3 = [u8_from_field_unsafe(to_field(l3_0) + to_field(m3_7)), u8_from_field_unsafe(to_field(l3_1) + to_field(m3_0)), u8_from_field_unsafe(to_field(l3_2) + to_field(m3_1)), u8_from_field_unsafe(to_field(l3_3) + to_field(m3_2)), u8_from_field_unsafe(to_field(l3_4) + to_field(m3_3)), u8_from_field_unsafe(to_field(l3_5) + to_field(m3_4)), u8_from_field_unsafe(to_field(l3_6) + to_field(m3_5)), u8_from_field_unsafe(to_field(l3_7) + to_field(m3_6))];
-      let (l4_0, m4_0) = u8_add(c4[0], c4[0]);
-      let (l4_1, m4_1) = u8_add(c4[1], c4[1]);
-      let (l4_2, m4_2) = u8_add(c4[2], c4[2]);
-      let (l4_3, m4_3) = u8_add(c4[3], c4[3]);
-      let (l4_4, m4_4) = u8_add(c4[4], c4[4]);
-      let (l4_5, m4_5) = u8_add(c4[5], c4[5]);
-      let (l4_6, m4_6) = u8_add(c4[6], c4[6]);
-      let (l4_7, m4_7) = u8_add(c4[7], c4[7]);
-      let r4 = [u8_from_field_unsafe(to_field(l4_0) + to_field(m4_7)), u8_from_field_unsafe(to_field(l4_1) + to_field(m4_0)), u8_from_field_unsafe(to_field(l4_2) + to_field(m4_1)), u8_from_field_unsafe(to_field(l4_3) + to_field(m4_2)), u8_from_field_unsafe(to_field(l4_4) + to_field(m4_3)), u8_from_field_unsafe(to_field(l4_5) + to_field(m4_4)), u8_from_field_unsafe(to_field(l4_6) + to_field(m4_5)), u8_from_field_unsafe(to_field(l4_7) + to_field(m4_6))];
-      -- D[x] = C[x-1] ^ rotl1(C[x+1]); A'[x,y] = A[x,y] ^ D[x].
-      let d0 = [u8_xor(c4[0], r1[0]), u8_xor(c4[1], r1[1]), u8_xor(c4[2], r1[2]), u8_xor(c4[3], r1[3]), u8_xor(c4[4], r1[4]), u8_xor(c4[5], r1[5]), u8_xor(c4[6], r1[6]), u8_xor(c4[7], r1[7])];
-      let d1 = [u8_xor(c0[0], r2[0]), u8_xor(c0[1], r2[1]), u8_xor(c0[2], r2[2]), u8_xor(c0[3], r2[3]), u8_xor(c0[4], r2[4]), u8_xor(c0[5], r2[5]), u8_xor(c0[6], r2[6]), u8_xor(c0[7], r2[7])];
-      let d2 = [u8_xor(c1[0], r3[0]), u8_xor(c1[1], r3[1]), u8_xor(c1[2], r3[2]), u8_xor(c1[3], r3[3]), u8_xor(c1[4], r3[4]), u8_xor(c1[5], r3[5]), u8_xor(c1[6], r3[6]), u8_xor(c1[7], r3[7])];
-      let d3 = [u8_xor(c2[0], r4[0]), u8_xor(c2[1], r4[1]), u8_xor(c2[2], r4[2]), u8_xor(c2[3], r4[3]), u8_xor(c2[4], r4[4]), u8_xor(c2[5], r4[5]), u8_xor(c2[6], r4[6]), u8_xor(c2[7], r4[7])];
-      let d4 = [u8_xor(c3[0], r0[0]), u8_xor(c3[1], r0[1]), u8_xor(c3[2], r0[2]), u8_xor(c3[3], r0[3]), u8_xor(c3[4], r0[4]), u8_xor(c3[5], r0[5]), u8_xor(c3[6], r0[6]), u8_xor(c3[7], r0[7])];
-      let t0 = [u8_xor(s[0][0], d0[0]), u8_xor(s[0][1], d0[1]), u8_xor(s[0][2], d0[2]), u8_xor(s[0][3], d0[3]), u8_xor(s[0][4], d0[4]), u8_xor(s[0][5], d0[5]), u8_xor(s[0][6], d0[6]), u8_xor(s[0][7], d0[7])];
-      let t1 = [u8_xor(s[1][0], d1[0]), u8_xor(s[1][1], d1[1]), u8_xor(s[1][2], d1[2]), u8_xor(s[1][3], d1[3]), u8_xor(s[1][4], d1[4]), u8_xor(s[1][5], d1[5]), u8_xor(s[1][6], d1[6]), u8_xor(s[1][7], d1[7])];
-      let t2 = [u8_xor(s[2][0], d2[0]), u8_xor(s[2][1], d2[1]), u8_xor(s[2][2], d2[2]), u8_xor(s[2][3], d2[3]), u8_xor(s[2][4], d2[4]), u8_xor(s[2][5], d2[5]), u8_xor(s[2][6], d2[6]), u8_xor(s[2][7], d2[7])];
-      let t3 = [u8_xor(s[3][0], d3[0]), u8_xor(s[3][1], d3[1]), u8_xor(s[3][2], d3[2]), u8_xor(s[3][3], d3[3]), u8_xor(s[3][4], d3[4]), u8_xor(s[3][5], d3[5]), u8_xor(s[3][6], d3[6]), u8_xor(s[3][7], d3[7])];
-      let t4 = [u8_xor(s[4][0], d4[0]), u8_xor(s[4][1], d4[1]), u8_xor(s[4][2], d4[2]), u8_xor(s[4][3], d4[3]), u8_xor(s[4][4], d4[4]), u8_xor(s[4][5], d4[5]), u8_xor(s[4][6], d4[6]), u8_xor(s[4][7], d4[7])];
-      let t5 = [u8_xor(s[5][0], d0[0]), u8_xor(s[5][1], d0[1]), u8_xor(s[5][2], d0[2]), u8_xor(s[5][3], d0[3]), u8_xor(s[5][4], d0[4]), u8_xor(s[5][5], d0[5]), u8_xor(s[5][6], d0[6]), u8_xor(s[5][7], d0[7])];
-      let t6 = [u8_xor(s[6][0], d1[0]), u8_xor(s[6][1], d1[1]), u8_xor(s[6][2], d1[2]), u8_xor(s[6][3], d1[3]), u8_xor(s[6][4], d1[4]), u8_xor(s[6][5], d1[5]), u8_xor(s[6][6], d1[6]), u8_xor(s[6][7], d1[7])];
-      let t7 = [u8_xor(s[7][0], d2[0]), u8_xor(s[7][1], d2[1]), u8_xor(s[7][2], d2[2]), u8_xor(s[7][3], d2[3]), u8_xor(s[7][4], d2[4]), u8_xor(s[7][5], d2[5]), u8_xor(s[7][6], d2[6]), u8_xor(s[7][7], d2[7])];
-      let t8 = [u8_xor(s[8][0], d3[0]), u8_xor(s[8][1], d3[1]), u8_xor(s[8][2], d3[2]), u8_xor(s[8][3], d3[3]), u8_xor(s[8][4], d3[4]), u8_xor(s[8][5], d3[5]), u8_xor(s[8][6], d3[6]), u8_xor(s[8][7], d3[7])];
-      let t9 = [u8_xor(s[9][0], d4[0]), u8_xor(s[9][1], d4[1]), u8_xor(s[9][2], d4[2]), u8_xor(s[9][3], d4[3]), u8_xor(s[9][4], d4[4]), u8_xor(s[9][5], d4[5]), u8_xor(s[9][6], d4[6]), u8_xor(s[9][7], d4[7])];
-      let t10 = [u8_xor(s[10][0], d0[0]), u8_xor(s[10][1], d0[1]), u8_xor(s[10][2], d0[2]), u8_xor(s[10][3], d0[3]), u8_xor(s[10][4], d0[4]), u8_xor(s[10][5], d0[5]), u8_xor(s[10][6], d0[6]), u8_xor(s[10][7], d0[7])];
-      let t11 = [u8_xor(s[11][0], d1[0]), u8_xor(s[11][1], d1[1]), u8_xor(s[11][2], d1[2]), u8_xor(s[11][3], d1[3]), u8_xor(s[11][4], d1[4]), u8_xor(s[11][5], d1[5]), u8_xor(s[11][6], d1[6]), u8_xor(s[11][7], d1[7])];
-      let t12 = [u8_xor(s[12][0], d2[0]), u8_xor(s[12][1], d2[1]), u8_xor(s[12][2], d2[2]), u8_xor(s[12][3], d2[3]), u8_xor(s[12][4], d2[4]), u8_xor(s[12][5], d2[5]), u8_xor(s[12][6], d2[6]), u8_xor(s[12][7], d2[7])];
-      let t13 = [u8_xor(s[13][0], d3[0]), u8_xor(s[13][1], d3[1]), u8_xor(s[13][2], d3[2]), u8_xor(s[13][3], d3[3]), u8_xor(s[13][4], d3[4]), u8_xor(s[13][5], d3[5]), u8_xor(s[13][6], d3[6]), u8_xor(s[13][7], d3[7])];
-      let t14 = [u8_xor(s[14][0], d4[0]), u8_xor(s[14][1], d4[1]), u8_xor(s[14][2], d4[2]), u8_xor(s[14][3], d4[3]), u8_xor(s[14][4], d4[4]), u8_xor(s[14][5], d4[5]), u8_xor(s[14][6], d4[6]), u8_xor(s[14][7], d4[7])];
-      let t15 = [u8_xor(s[15][0], d0[0]), u8_xor(s[15][1], d0[1]), u8_xor(s[15][2], d0[2]), u8_xor(s[15][3], d0[3]), u8_xor(s[15][4], d0[4]), u8_xor(s[15][5], d0[5]), u8_xor(s[15][6], d0[6]), u8_xor(s[15][7], d0[7])];
-      let t16 = [u8_xor(s[16][0], d1[0]), u8_xor(s[16][1], d1[1]), u8_xor(s[16][2], d1[2]), u8_xor(s[16][3], d1[3]), u8_xor(s[16][4], d1[4]), u8_xor(s[16][5], d1[5]), u8_xor(s[16][6], d1[6]), u8_xor(s[16][7], d1[7])];
-      let t17 = [u8_xor(s[17][0], d2[0]), u8_xor(s[17][1], d2[1]), u8_xor(s[17][2], d2[2]), u8_xor(s[17][3], d2[3]), u8_xor(s[17][4], d2[4]), u8_xor(s[17][5], d2[5]), u8_xor(s[17][6], d2[6]), u8_xor(s[17][7], d2[7])];
-      let t18 = [u8_xor(s[18][0], d3[0]), u8_xor(s[18][1], d3[1]), u8_xor(s[18][2], d3[2]), u8_xor(s[18][3], d3[3]), u8_xor(s[18][4], d3[4]), u8_xor(s[18][5], d3[5]), u8_xor(s[18][6], d3[6]), u8_xor(s[18][7], d3[7])];
-      let t19 = [u8_xor(s[19][0], d4[0]), u8_xor(s[19][1], d4[1]), u8_xor(s[19][2], d4[2]), u8_xor(s[19][3], d4[3]), u8_xor(s[19][4], d4[4]), u8_xor(s[19][5], d4[5]), u8_xor(s[19][6], d4[6]), u8_xor(s[19][7], d4[7])];
-      let t20 = [u8_xor(s[20][0], d0[0]), u8_xor(s[20][1], d0[1]), u8_xor(s[20][2], d0[2]), u8_xor(s[20][3], d0[3]), u8_xor(s[20][4], d0[4]), u8_xor(s[20][5], d0[5]), u8_xor(s[20][6], d0[6]), u8_xor(s[20][7], d0[7])];
-      let t21 = [u8_xor(s[21][0], d1[0]), u8_xor(s[21][1], d1[1]), u8_xor(s[21][2], d1[2]), u8_xor(s[21][3], d1[3]), u8_xor(s[21][4], d1[4]), u8_xor(s[21][5], d1[5]), u8_xor(s[21][6], d1[6]), u8_xor(s[21][7], d1[7])];
-      let t22 = [u8_xor(s[22][0], d2[0]), u8_xor(s[22][1], d2[1]), u8_xor(s[22][2], d2[2]), u8_xor(s[22][3], d2[3]), u8_xor(s[22][4], d2[4]), u8_xor(s[22][5], d2[5]), u8_xor(s[22][6], d2[6]), u8_xor(s[22][7], d2[7])];
-      let t23 = [u8_xor(s[23][0], d3[0]), u8_xor(s[23][1], d3[1]), u8_xor(s[23][2], d3[2]), u8_xor(s[23][3], d3[3]), u8_xor(s[23][4], d3[4]), u8_xor(s[23][5], d3[5]), u8_xor(s[23][6], d3[6]), u8_xor(s[23][7], d3[7])];
-      let t24 = [u8_xor(s[24][0], d4[0]), u8_xor(s[24][1], d4[1]), u8_xor(s[24][2], d4[2]), u8_xor(s[24][3], d4[3]), u8_xor(s[24][4], d4[4]), u8_xor(s[24][5], d4[5]), u8_xor(s[24][6], d4[6]), u8_xor(s[24][7], d4[7])];
-      [t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24]
-  }
-
-  fn keccak_rho_chi_iota(s: [[U8; 8]; 25], rc: [U8; 8]) -> [[U8; 8]; 25] {
-      let t0 = s[0];
-      let t1 = s[1];
-      let t2 = s[2];
-      let t3 = s[3];
-      let t4 = s[4];
-      let t5 = s[5];
-      let t6 = s[6];
-      let t7 = s[7];
-      let t8 = s[8];
-      let t9 = s[9];
-      let t10 = s[10];
-      let t11 = s[11];
-      let t12 = s[12];
-      let t13 = s[13];
-      let t14 = s[14];
-      let t15 = s[15];
-      let t16 = s[16];
-      let t17 = s[17];
-      let t18 = s[18];
-      let t19 = s[19];
-      let t20 = s[20];
-      let t21 = s[21];
-      let t22 = s[22];
-      let t23 = s[23];
-      let t24 = s[24];
-      -- rho + pi: b[pi(src)] = rotl(t[src], rho(src)).
-      -- b0 = rotl(t0, 0): byte rotation only (free)
-      let b0 = [t0[0], t0[1], t0[2], t0[3], t0[4], t0[5], t0[6], t0[7]];
-      -- b10 = rotl(t1, 1) = byte-rotl 0 + 1x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a10_0_0, c10_0_0) = u8_add(t1[0], t1[0]);
-      let (a10_0_1, c10_0_1) = u8_add(t1[1], t1[1]);
-      let (a10_0_2, c10_0_2) = u8_add(t1[2], t1[2]);
-      let (a10_0_3, c10_0_3) = u8_add(t1[3], t1[3]);
-      let (a10_0_4, c10_0_4) = u8_add(t1[4], t1[4]);
-      let (a10_0_5, c10_0_5) = u8_add(t1[5], t1[5]);
-      let (a10_0_6, c10_0_6) = u8_add(t1[6], t1[6]);
-      let (a10_0_7, c10_0_7) = u8_add(t1[7], t1[7]);
-      let b10 = [u8_from_field_unsafe(to_field(a10_0_0) + to_field(c10_0_7)), u8_from_field_unsafe(to_field(a10_0_1) + to_field(c10_0_0)), u8_from_field_unsafe(to_field(a10_0_2) + to_field(c10_0_1)), u8_from_field_unsafe(to_field(a10_0_3) + to_field(c10_0_2)), u8_from_field_unsafe(to_field(a10_0_4) + to_field(c10_0_3)), u8_from_field_unsafe(to_field(a10_0_5) + to_field(c10_0_4)), u8_from_field_unsafe(to_field(a10_0_6) + to_field(c10_0_5)), u8_from_field_unsafe(to_field(a10_0_7) + to_field(c10_0_6))];
-      -- b20 = rotl(t2, 62) = byte-rotl 8 + 2x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h20_0_0 = u8_shift_right(t2[0]);
-      let h20_0_1 = u8_shift_right(t2[1]);
-      let h20_0_2 = u8_shift_right(t2[2]);
-      let h20_0_3 = u8_shift_right(t2[3]);
-      let h20_0_4 = u8_shift_right(t2[4]);
-      let h20_0_5 = u8_shift_right(t2[5]);
-      let h20_0_6 = u8_shift_right(t2[6]);
-      let h20_0_7 = u8_shift_right(t2[7]);
-      let h20_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0) + 128 * (to_field(t2[1]) - 2 * to_field(h20_0_1))));
-      let h20_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_1) + 128 * (to_field(t2[2]) - 2 * to_field(h20_0_2))));
-      let h20_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_2) + 128 * (to_field(t2[3]) - 2 * to_field(h20_0_3))));
-      let h20_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_3) + 128 * (to_field(t2[4]) - 2 * to_field(h20_0_4))));
-      let h20_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_4) + 128 * (to_field(t2[5]) - 2 * to_field(h20_0_5))));
-      let h20_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_5) + 128 * (to_field(t2[6]) - 2 * to_field(h20_0_6))));
-      let h20_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_6) + 128 * (to_field(t2[7]) - 2 * to_field(h20_0_7))));
-      let h20_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_7) + 128 * (to_field(t2[0]) - 2 * to_field(h20_0_0))));
-      let b20 = [u8_from_field_unsafe(to_field(h20_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_1) + 128 * (to_field(t2[2]) - 2 * to_field(h20_0_2)))) - 2 * to_field(h20_1_1))), u8_from_field_unsafe(to_field(h20_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_2) + 128 * (to_field(t2[3]) - 2 * to_field(h20_0_3)))) - 2 * to_field(h20_1_2))), u8_from_field_unsafe(to_field(h20_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_3) + 128 * (to_field(t2[4]) - 2 * to_field(h20_0_4)))) - 2 * to_field(h20_1_3))), u8_from_field_unsafe(to_field(h20_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_4) + 128 * (to_field(t2[5]) - 2 * to_field(h20_0_5)))) - 2 * to_field(h20_1_4))), u8_from_field_unsafe(to_field(h20_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_5) + 128 * (to_field(t2[6]) - 2 * to_field(h20_0_6)))) - 2 * to_field(h20_1_5))), u8_from_field_unsafe(to_field(h20_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_6) + 128 * (to_field(t2[7]) - 2 * to_field(h20_0_7)))) - 2 * to_field(h20_1_6))), u8_from_field_unsafe(to_field(h20_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_7) + 128 * (to_field(t2[0]) - 2 * to_field(h20_0_0)))) - 2 * to_field(h20_1_7))), u8_from_field_unsafe(to_field(h20_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0) + 128 * (to_field(t2[1]) - 2 * to_field(h20_0_1)))) - 2 * to_field(h20_1_0)))];
-      -- b5 = rotl(t3, 28) = byte-rotl 3 + bit-shl 4 (decomposition)
-      let d5_0 = u8_bit_decomposition(t3[0]);
-      let d5_1 = u8_bit_decomposition(t3[1]);
-      let d5_2 = u8_bit_decomposition(t3[2]);
-      let d5_3 = u8_bit_decomposition(t3[3]);
-      let d5_4 = u8_bit_decomposition(t3[4]);
-      let d5_5 = u8_bit_decomposition(t3[5]);
-      let d5_6 = u8_bit_decomposition(t3[6]);
-      let d5_7 = u8_bit_decomposition(t3[7]);
-      let b5 = [u8_from_field_unsafe(d5_4[4] + 2 * d5_4[5] + 4 * d5_4[6] + 8 * d5_4[7] + 16 * d5_5[0] + 32 * d5_5[1] + 64 * d5_5[2] + 128 * d5_5[3]), u8_from_field_unsafe(d5_5[4] + 2 * d5_5[5] + 4 * d5_5[6] + 8 * d5_5[7] + 16 * d5_6[0] + 32 * d5_6[1] + 64 * d5_6[2] + 128 * d5_6[3]), u8_from_field_unsafe(d5_6[4] + 2 * d5_6[5] + 4 * d5_6[6] + 8 * d5_6[7] + 16 * d5_7[0] + 32 * d5_7[1] + 64 * d5_7[2] + 128 * d5_7[3]), u8_from_field_unsafe(d5_7[4] + 2 * d5_7[5] + 4 * d5_7[6] + 8 * d5_7[7] + 16 * d5_0[0] + 32 * d5_0[1] + 64 * d5_0[2] + 128 * d5_0[3]), u8_from_field_unsafe(d5_0[4] + 2 * d5_0[5] + 4 * d5_0[6] + 8 * d5_0[7] + 16 * d5_1[0] + 32 * d5_1[1] + 64 * d5_1[2] + 128 * d5_1[3]), u8_from_field_unsafe(d5_1[4] + 2 * d5_1[5] + 4 * d5_1[6] + 8 * d5_1[7] + 16 * d5_2[0] + 32 * d5_2[1] + 64 * d5_2[2] + 128 * d5_2[3]), u8_from_field_unsafe(d5_2[4] + 2 * d5_2[5] + 4 * d5_2[6] + 8 * d5_2[7] + 16 * d5_3[0] + 32 * d5_3[1] + 64 * d5_3[2] + 128 * d5_3[3]), u8_from_field_unsafe(d5_3[4] + 2 * d5_3[5] + 4 * d5_3[6] + 8 * d5_3[7] + 16 * d5_4[0] + 32 * d5_4[1] + 64 * d5_4[2] + 128 * d5_4[3])];
-      -- b15 = rotl(t4, 27) = byte-rotl 3 + 3x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a15_0_0, c15_0_0) = u8_add(t4[5], t4[5]);
-      let (a15_0_1, c15_0_1) = u8_add(t4[6], t4[6]);
-      let (a15_0_2, c15_0_2) = u8_add(t4[7], t4[7]);
-      let (a15_0_3, c15_0_3) = u8_add(t4[0], t4[0]);
-      let (a15_0_4, c15_0_4) = u8_add(t4[1], t4[1]);
-      let (a15_0_5, c15_0_5) = u8_add(t4[2], t4[2]);
-      let (a15_0_6, c15_0_6) = u8_add(t4[3], t4[3]);
-      let (a15_0_7, c15_0_7) = u8_add(t4[4], t4[4]);
-      let (a15_1_0, c15_1_0) = u8_add(u8_from_field_unsafe(to_field(a15_0_0) + to_field(c15_0_7)), u8_from_field_unsafe(to_field(a15_0_0) + to_field(c15_0_7)));
-      let (a15_1_1, c15_1_1) = u8_add(u8_from_field_unsafe(to_field(a15_0_1) + to_field(c15_0_0)), u8_from_field_unsafe(to_field(a15_0_1) + to_field(c15_0_0)));
-      let (a15_1_2, c15_1_2) = u8_add(u8_from_field_unsafe(to_field(a15_0_2) + to_field(c15_0_1)), u8_from_field_unsafe(to_field(a15_0_2) + to_field(c15_0_1)));
-      let (a15_1_3, c15_1_3) = u8_add(u8_from_field_unsafe(to_field(a15_0_3) + to_field(c15_0_2)), u8_from_field_unsafe(to_field(a15_0_3) + to_field(c15_0_2)));
-      let (a15_1_4, c15_1_4) = u8_add(u8_from_field_unsafe(to_field(a15_0_4) + to_field(c15_0_3)), u8_from_field_unsafe(to_field(a15_0_4) + to_field(c15_0_3)));
-      let (a15_1_5, c15_1_5) = u8_add(u8_from_field_unsafe(to_field(a15_0_5) + to_field(c15_0_4)), u8_from_field_unsafe(to_field(a15_0_5) + to_field(c15_0_4)));
-      let (a15_1_6, c15_1_6) = u8_add(u8_from_field_unsafe(to_field(a15_0_6) + to_field(c15_0_5)), u8_from_field_unsafe(to_field(a15_0_6) + to_field(c15_0_5)));
-      let (a15_1_7, c15_1_7) = u8_add(u8_from_field_unsafe(to_field(a15_0_7) + to_field(c15_0_6)), u8_from_field_unsafe(to_field(a15_0_7) + to_field(c15_0_6)));
-      let (a15_2_0, c15_2_0) = u8_add(u8_from_field_unsafe(to_field(a15_1_0) + to_field(c15_1_7)), u8_from_field_unsafe(to_field(a15_1_0) + to_field(c15_1_7)));
-      let (a15_2_1, c15_2_1) = u8_add(u8_from_field_unsafe(to_field(a15_1_1) + to_field(c15_1_0)), u8_from_field_unsafe(to_field(a15_1_1) + to_field(c15_1_0)));
-      let (a15_2_2, c15_2_2) = u8_add(u8_from_field_unsafe(to_field(a15_1_2) + to_field(c15_1_1)), u8_from_field_unsafe(to_field(a15_1_2) + to_field(c15_1_1)));
-      let (a15_2_3, c15_2_3) = u8_add(u8_from_field_unsafe(to_field(a15_1_3) + to_field(c15_1_2)), u8_from_field_unsafe(to_field(a15_1_3) + to_field(c15_1_2)));
-      let (a15_2_4, c15_2_4) = u8_add(u8_from_field_unsafe(to_field(a15_1_4) + to_field(c15_1_3)), u8_from_field_unsafe(to_field(a15_1_4) + to_field(c15_1_3)));
-      let (a15_2_5, c15_2_5) = u8_add(u8_from_field_unsafe(to_field(a15_1_5) + to_field(c15_1_4)), u8_from_field_unsafe(to_field(a15_1_5) + to_field(c15_1_4)));
-      let (a15_2_6, c15_2_6) = u8_add(u8_from_field_unsafe(to_field(a15_1_6) + to_field(c15_1_5)), u8_from_field_unsafe(to_field(a15_1_6) + to_field(c15_1_5)));
-      let (a15_2_7, c15_2_7) = u8_add(u8_from_field_unsafe(to_field(a15_1_7) + to_field(c15_1_6)), u8_from_field_unsafe(to_field(a15_1_7) + to_field(c15_1_6)));
-      let b15 = [u8_from_field_unsafe(to_field(a15_2_0) + to_field(c15_2_7)), u8_from_field_unsafe(to_field(a15_2_1) + to_field(c15_2_0)), u8_from_field_unsafe(to_field(a15_2_2) + to_field(c15_2_1)), u8_from_field_unsafe(to_field(a15_2_3) + to_field(c15_2_2)), u8_from_field_unsafe(to_field(a15_2_4) + to_field(c15_2_3)), u8_from_field_unsafe(to_field(a15_2_5) + to_field(c15_2_4)), u8_from_field_unsafe(to_field(a15_2_6) + to_field(c15_2_5)), u8_from_field_unsafe(to_field(a15_2_7) + to_field(c15_2_6))];
-      -- b16 = rotl(t5, 36) = byte-rotl 4 + bit-shl 4 (decomposition)
-      let d16_0 = u8_bit_decomposition(t5[0]);
-      let d16_1 = u8_bit_decomposition(t5[1]);
-      let d16_2 = u8_bit_decomposition(t5[2]);
-      let d16_3 = u8_bit_decomposition(t5[3]);
-      let d16_4 = u8_bit_decomposition(t5[4]);
-      let d16_5 = u8_bit_decomposition(t5[5]);
-      let d16_6 = u8_bit_decomposition(t5[6]);
-      let d16_7 = u8_bit_decomposition(t5[7]);
-      let b16 = [u8_from_field_unsafe(d16_3[4] + 2 * d16_3[5] + 4 * d16_3[6] + 8 * d16_3[7] + 16 * d16_4[0] + 32 * d16_4[1] + 64 * d16_4[2] + 128 * d16_4[3]), u8_from_field_unsafe(d16_4[4] + 2 * d16_4[5] + 4 * d16_4[6] + 8 * d16_4[7] + 16 * d16_5[0] + 32 * d16_5[1] + 64 * d16_5[2] + 128 * d16_5[3]), u8_from_field_unsafe(d16_5[4] + 2 * d16_5[5] + 4 * d16_5[6] + 8 * d16_5[7] + 16 * d16_6[0] + 32 * d16_6[1] + 64 * d16_6[2] + 128 * d16_6[3]), u8_from_field_unsafe(d16_6[4] + 2 * d16_6[5] + 4 * d16_6[6] + 8 * d16_6[7] + 16 * d16_7[0] + 32 * d16_7[1] + 64 * d16_7[2] + 128 * d16_7[3]), u8_from_field_unsafe(d16_7[4] + 2 * d16_7[5] + 4 * d16_7[6] + 8 * d16_7[7] + 16 * d16_0[0] + 32 * d16_0[1] + 64 * d16_0[2] + 128 * d16_0[3]), u8_from_field_unsafe(d16_0[4] + 2 * d16_0[5] + 4 * d16_0[6] + 8 * d16_0[7] + 16 * d16_1[0] + 32 * d16_1[1] + 64 * d16_1[2] + 128 * d16_1[3]), u8_from_field_unsafe(d16_1[4] + 2 * d16_1[5] + 4 * d16_1[6] + 8 * d16_1[7] + 16 * d16_2[0] + 32 * d16_2[1] + 64 * d16_2[2] + 128 * d16_2[3]), u8_from_field_unsafe(d16_2[4] + 2 * d16_2[5] + 4 * d16_2[6] + 8 * d16_2[7] + 16 * d16_3[0] + 32 * d16_3[1] + 64 * d16_3[2] + 128 * d16_3[3])];
-      -- b1 = rotl(t6, 44) = byte-rotl 5 + bit-shl 4 (decomposition)
-      let d1_0 = u8_bit_decomposition(t6[0]);
-      let d1_1 = u8_bit_decomposition(t6[1]);
-      let d1_2 = u8_bit_decomposition(t6[2]);
-      let d1_3 = u8_bit_decomposition(t6[3]);
-      let d1_4 = u8_bit_decomposition(t6[4]);
-      let d1_5 = u8_bit_decomposition(t6[5]);
-      let d1_6 = u8_bit_decomposition(t6[6]);
-      let d1_7 = u8_bit_decomposition(t6[7]);
-      let b1 = [u8_from_field_unsafe(d1_2[4] + 2 * d1_2[5] + 4 * d1_2[6] + 8 * d1_2[7] + 16 * d1_3[0] + 32 * d1_3[1] + 64 * d1_3[2] + 128 * d1_3[3]), u8_from_field_unsafe(d1_3[4] + 2 * d1_3[5] + 4 * d1_3[6] + 8 * d1_3[7] + 16 * d1_4[0] + 32 * d1_4[1] + 64 * d1_4[2] + 128 * d1_4[3]), u8_from_field_unsafe(d1_4[4] + 2 * d1_4[5] + 4 * d1_4[6] + 8 * d1_4[7] + 16 * d1_5[0] + 32 * d1_5[1] + 64 * d1_5[2] + 128 * d1_5[3]), u8_from_field_unsafe(d1_5[4] + 2 * d1_5[5] + 4 * d1_5[6] + 8 * d1_5[7] + 16 * d1_6[0] + 32 * d1_6[1] + 64 * d1_6[2] + 128 * d1_6[3]), u8_from_field_unsafe(d1_6[4] + 2 * d1_6[5] + 4 * d1_6[6] + 8 * d1_6[7] + 16 * d1_7[0] + 32 * d1_7[1] + 64 * d1_7[2] + 128 * d1_7[3]), u8_from_field_unsafe(d1_7[4] + 2 * d1_7[5] + 4 * d1_7[6] + 8 * d1_7[7] + 16 * d1_0[0] + 32 * d1_0[1] + 64 * d1_0[2] + 128 * d1_0[3]), u8_from_field_unsafe(d1_0[4] + 2 * d1_0[5] + 4 * d1_0[6] + 8 * d1_0[7] + 16 * d1_1[0] + 32 * d1_1[1] + 64 * d1_1[2] + 128 * d1_1[3]), u8_from_field_unsafe(d1_1[4] + 2 * d1_1[5] + 4 * d1_1[6] + 8 * d1_1[7] + 16 * d1_2[0] + 32 * d1_2[1] + 64 * d1_2[2] + 128 * d1_2[3])];
-      -- b11 = rotl(t7, 6) = byte-rotl 1 + 2x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h11_0_0 = u8_shift_right(t7[7]);
-      let h11_0_1 = u8_shift_right(t7[0]);
-      let h11_0_2 = u8_shift_right(t7[1]);
-      let h11_0_3 = u8_shift_right(t7[2]);
-      let h11_0_4 = u8_shift_right(t7[3]);
-      let h11_0_5 = u8_shift_right(t7[4]);
-      let h11_0_6 = u8_shift_right(t7[5]);
-      let h11_0_7 = u8_shift_right(t7[6]);
-      let h11_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0) + 128 * (to_field(t7[0]) - 2 * to_field(h11_0_1))));
-      let h11_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_1) + 128 * (to_field(t7[1]) - 2 * to_field(h11_0_2))));
-      let h11_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_2) + 128 * (to_field(t7[2]) - 2 * to_field(h11_0_3))));
-      let h11_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_3) + 128 * (to_field(t7[3]) - 2 * to_field(h11_0_4))));
-      let h11_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_4) + 128 * (to_field(t7[4]) - 2 * to_field(h11_0_5))));
-      let h11_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_5) + 128 * (to_field(t7[5]) - 2 * to_field(h11_0_6))));
-      let h11_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_6) + 128 * (to_field(t7[6]) - 2 * to_field(h11_0_7))));
-      let h11_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_7) + 128 * (to_field(t7[7]) - 2 * to_field(h11_0_0))));
-      let b11 = [u8_from_field_unsafe(to_field(h11_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_1) + 128 * (to_field(t7[1]) - 2 * to_field(h11_0_2)))) - 2 * to_field(h11_1_1))), u8_from_field_unsafe(to_field(h11_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_2) + 128 * (to_field(t7[2]) - 2 * to_field(h11_0_3)))) - 2 * to_field(h11_1_2))), u8_from_field_unsafe(to_field(h11_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_3) + 128 * (to_field(t7[3]) - 2 * to_field(h11_0_4)))) - 2 * to_field(h11_1_3))), u8_from_field_unsafe(to_field(h11_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_4) + 128 * (to_field(t7[4]) - 2 * to_field(h11_0_5)))) - 2 * to_field(h11_1_4))), u8_from_field_unsafe(to_field(h11_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_5) + 128 * (to_field(t7[5]) - 2 * to_field(h11_0_6)))) - 2 * to_field(h11_1_5))), u8_from_field_unsafe(to_field(h11_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_6) + 128 * (to_field(t7[6]) - 2 * to_field(h11_0_7)))) - 2 * to_field(h11_1_6))), u8_from_field_unsafe(to_field(h11_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_7) + 128 * (to_field(t7[7]) - 2 * to_field(h11_0_0)))) - 2 * to_field(h11_1_7))), u8_from_field_unsafe(to_field(h11_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0) + 128 * (to_field(t7[0]) - 2 * to_field(h11_0_1)))) - 2 * to_field(h11_1_0)))];
-      -- b21 = rotl(t8, 55) = byte-rotl 7 + 1x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h21_0_0 = u8_shift_right(t8[1]);
-      let h21_0_1 = u8_shift_right(t8[2]);
-      let h21_0_2 = u8_shift_right(t8[3]);
-      let h21_0_3 = u8_shift_right(t8[4]);
-      let h21_0_4 = u8_shift_right(t8[5]);
-      let h21_0_5 = u8_shift_right(t8[6]);
-      let h21_0_6 = u8_shift_right(t8[7]);
-      let h21_0_7 = u8_shift_right(t8[0]);
-      let b21 = [u8_from_field_unsafe(to_field(h21_0_0) + 128 * (to_field(t8[2]) - 2 * to_field(h21_0_1))), u8_from_field_unsafe(to_field(h21_0_1) + 128 * (to_field(t8[3]) - 2 * to_field(h21_0_2))), u8_from_field_unsafe(to_field(h21_0_2) + 128 * (to_field(t8[4]) - 2 * to_field(h21_0_3))), u8_from_field_unsafe(to_field(h21_0_3) + 128 * (to_field(t8[5]) - 2 * to_field(h21_0_4))), u8_from_field_unsafe(to_field(h21_0_4) + 128 * (to_field(t8[6]) - 2 * to_field(h21_0_5))), u8_from_field_unsafe(to_field(h21_0_5) + 128 * (to_field(t8[7]) - 2 * to_field(h21_0_6))), u8_from_field_unsafe(to_field(h21_0_6) + 128 * (to_field(t8[0]) - 2 * to_field(h21_0_7))), u8_from_field_unsafe(to_field(h21_0_7) + 128 * (to_field(t8[1]) - 2 * to_field(h21_0_0)))];
-      -- b6 = rotl(t9, 20) = byte-rotl 2 + bit-shl 4 (decomposition)
-      let d6_0 = u8_bit_decomposition(t9[0]);
-      let d6_1 = u8_bit_decomposition(t9[1]);
-      let d6_2 = u8_bit_decomposition(t9[2]);
-      let d6_3 = u8_bit_decomposition(t9[3]);
-      let d6_4 = u8_bit_decomposition(t9[4]);
-      let d6_5 = u8_bit_decomposition(t9[5]);
-      let d6_6 = u8_bit_decomposition(t9[6]);
-      let d6_7 = u8_bit_decomposition(t9[7]);
-      let b6 = [u8_from_field_unsafe(d6_5[4] + 2 * d6_5[5] + 4 * d6_5[6] + 8 * d6_5[7] + 16 * d6_6[0] + 32 * d6_6[1] + 64 * d6_6[2] + 128 * d6_6[3]), u8_from_field_unsafe(d6_6[4] + 2 * d6_6[5] + 4 * d6_6[6] + 8 * d6_6[7] + 16 * d6_7[0] + 32 * d6_7[1] + 64 * d6_7[2] + 128 * d6_7[3]), u8_from_field_unsafe(d6_7[4] + 2 * d6_7[5] + 4 * d6_7[6] + 8 * d6_7[7] + 16 * d6_0[0] + 32 * d6_0[1] + 64 * d6_0[2] + 128 * d6_0[3]), u8_from_field_unsafe(d6_0[4] + 2 * d6_0[5] + 4 * d6_0[6] + 8 * d6_0[7] + 16 * d6_1[0] + 32 * d6_1[1] + 64 * d6_1[2] + 128 * d6_1[3]), u8_from_field_unsafe(d6_1[4] + 2 * d6_1[5] + 4 * d6_1[6] + 8 * d6_1[7] + 16 * d6_2[0] + 32 * d6_2[1] + 64 * d6_2[2] + 128 * d6_2[3]), u8_from_field_unsafe(d6_2[4] + 2 * d6_2[5] + 4 * d6_2[6] + 8 * d6_2[7] + 16 * d6_3[0] + 32 * d6_3[1] + 64 * d6_3[2] + 128 * d6_3[3]), u8_from_field_unsafe(d6_3[4] + 2 * d6_3[5] + 4 * d6_3[6] + 8 * d6_3[7] + 16 * d6_4[0] + 32 * d6_4[1] + 64 * d6_4[2] + 128 * d6_4[3]), u8_from_field_unsafe(d6_4[4] + 2 * d6_4[5] + 4 * d6_4[6] + 8 * d6_4[7] + 16 * d6_5[0] + 32 * d6_5[1] + 64 * d6_5[2] + 128 * d6_5[3])];
-      -- b7 = rotl(t10, 3) = byte-rotl 0 + 3x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a7_0_0, c7_0_0) = u8_add(t10[0], t10[0]);
-      let (a7_0_1, c7_0_1) = u8_add(t10[1], t10[1]);
-      let (a7_0_2, c7_0_2) = u8_add(t10[2], t10[2]);
-      let (a7_0_3, c7_0_3) = u8_add(t10[3], t10[3]);
-      let (a7_0_4, c7_0_4) = u8_add(t10[4], t10[4]);
-      let (a7_0_5, c7_0_5) = u8_add(t10[5], t10[5]);
-      let (a7_0_6, c7_0_6) = u8_add(t10[6], t10[6]);
-      let (a7_0_7, c7_0_7) = u8_add(t10[7], t10[7]);
-      let (a7_1_0, c7_1_0) = u8_add(u8_from_field_unsafe(to_field(a7_0_0) + to_field(c7_0_7)), u8_from_field_unsafe(to_field(a7_0_0) + to_field(c7_0_7)));
-      let (a7_1_1, c7_1_1) = u8_add(u8_from_field_unsafe(to_field(a7_0_1) + to_field(c7_0_0)), u8_from_field_unsafe(to_field(a7_0_1) + to_field(c7_0_0)));
-      let (a7_1_2, c7_1_2) = u8_add(u8_from_field_unsafe(to_field(a7_0_2) + to_field(c7_0_1)), u8_from_field_unsafe(to_field(a7_0_2) + to_field(c7_0_1)));
-      let (a7_1_3, c7_1_3) = u8_add(u8_from_field_unsafe(to_field(a7_0_3) + to_field(c7_0_2)), u8_from_field_unsafe(to_field(a7_0_3) + to_field(c7_0_2)));
-      let (a7_1_4, c7_1_4) = u8_add(u8_from_field_unsafe(to_field(a7_0_4) + to_field(c7_0_3)), u8_from_field_unsafe(to_field(a7_0_4) + to_field(c7_0_3)));
-      let (a7_1_5, c7_1_5) = u8_add(u8_from_field_unsafe(to_field(a7_0_5) + to_field(c7_0_4)), u8_from_field_unsafe(to_field(a7_0_5) + to_field(c7_0_4)));
-      let (a7_1_6, c7_1_6) = u8_add(u8_from_field_unsafe(to_field(a7_0_6) + to_field(c7_0_5)), u8_from_field_unsafe(to_field(a7_0_6) + to_field(c7_0_5)));
-      let (a7_1_7, c7_1_7) = u8_add(u8_from_field_unsafe(to_field(a7_0_7) + to_field(c7_0_6)), u8_from_field_unsafe(to_field(a7_0_7) + to_field(c7_0_6)));
-      let (a7_2_0, c7_2_0) = u8_add(u8_from_field_unsafe(to_field(a7_1_0) + to_field(c7_1_7)), u8_from_field_unsafe(to_field(a7_1_0) + to_field(c7_1_7)));
-      let (a7_2_1, c7_2_1) = u8_add(u8_from_field_unsafe(to_field(a7_1_1) + to_field(c7_1_0)), u8_from_field_unsafe(to_field(a7_1_1) + to_field(c7_1_0)));
-      let (a7_2_2, c7_2_2) = u8_add(u8_from_field_unsafe(to_field(a7_1_2) + to_field(c7_1_1)), u8_from_field_unsafe(to_field(a7_1_2) + to_field(c7_1_1)));
-      let (a7_2_3, c7_2_3) = u8_add(u8_from_field_unsafe(to_field(a7_1_3) + to_field(c7_1_2)), u8_from_field_unsafe(to_field(a7_1_3) + to_field(c7_1_2)));
-      let (a7_2_4, c7_2_4) = u8_add(u8_from_field_unsafe(to_field(a7_1_4) + to_field(c7_1_3)), u8_from_field_unsafe(to_field(a7_1_4) + to_field(c7_1_3)));
-      let (a7_2_5, c7_2_5) = u8_add(u8_from_field_unsafe(to_field(a7_1_5) + to_field(c7_1_4)), u8_from_field_unsafe(to_field(a7_1_5) + to_field(c7_1_4)));
-      let (a7_2_6, c7_2_6) = u8_add(u8_from_field_unsafe(to_field(a7_1_6) + to_field(c7_1_5)), u8_from_field_unsafe(to_field(a7_1_6) + to_field(c7_1_5)));
-      let (a7_2_7, c7_2_7) = u8_add(u8_from_field_unsafe(to_field(a7_1_7) + to_field(c7_1_6)), u8_from_field_unsafe(to_field(a7_1_7) + to_field(c7_1_6)));
-      let b7 = [u8_from_field_unsafe(to_field(a7_2_0) + to_field(c7_2_7)), u8_from_field_unsafe(to_field(a7_2_1) + to_field(c7_2_0)), u8_from_field_unsafe(to_field(a7_2_2) + to_field(c7_2_1)), u8_from_field_unsafe(to_field(a7_2_3) + to_field(c7_2_2)), u8_from_field_unsafe(to_field(a7_2_4) + to_field(c7_2_3)), u8_from_field_unsafe(to_field(a7_2_5) + to_field(c7_2_4)), u8_from_field_unsafe(to_field(a7_2_6) + to_field(c7_2_5)), u8_from_field_unsafe(to_field(a7_2_7) + to_field(c7_2_6))];
-      -- b17 = rotl(t11, 10) = byte-rotl 1 + 2x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a17_0_0, c17_0_0) = u8_add(t11[7], t11[7]);
-      let (a17_0_1, c17_0_1) = u8_add(t11[0], t11[0]);
-      let (a17_0_2, c17_0_2) = u8_add(t11[1], t11[1]);
-      let (a17_0_3, c17_0_3) = u8_add(t11[2], t11[2]);
-      let (a17_0_4, c17_0_4) = u8_add(t11[3], t11[3]);
-      let (a17_0_5, c17_0_5) = u8_add(t11[4], t11[4]);
-      let (a17_0_6, c17_0_6) = u8_add(t11[5], t11[5]);
-      let (a17_0_7, c17_0_7) = u8_add(t11[6], t11[6]);
-      let (a17_1_0, c17_1_0) = u8_add(u8_from_field_unsafe(to_field(a17_0_0) + to_field(c17_0_7)), u8_from_field_unsafe(to_field(a17_0_0) + to_field(c17_0_7)));
-      let (a17_1_1, c17_1_1) = u8_add(u8_from_field_unsafe(to_field(a17_0_1) + to_field(c17_0_0)), u8_from_field_unsafe(to_field(a17_0_1) + to_field(c17_0_0)));
-      let (a17_1_2, c17_1_2) = u8_add(u8_from_field_unsafe(to_field(a17_0_2) + to_field(c17_0_1)), u8_from_field_unsafe(to_field(a17_0_2) + to_field(c17_0_1)));
-      let (a17_1_3, c17_1_3) = u8_add(u8_from_field_unsafe(to_field(a17_0_3) + to_field(c17_0_2)), u8_from_field_unsafe(to_field(a17_0_3) + to_field(c17_0_2)));
-      let (a17_1_4, c17_1_4) = u8_add(u8_from_field_unsafe(to_field(a17_0_4) + to_field(c17_0_3)), u8_from_field_unsafe(to_field(a17_0_4) + to_field(c17_0_3)));
-      let (a17_1_5, c17_1_5) = u8_add(u8_from_field_unsafe(to_field(a17_0_5) + to_field(c17_0_4)), u8_from_field_unsafe(to_field(a17_0_5) + to_field(c17_0_4)));
-      let (a17_1_6, c17_1_6) = u8_add(u8_from_field_unsafe(to_field(a17_0_6) + to_field(c17_0_5)), u8_from_field_unsafe(to_field(a17_0_6) + to_field(c17_0_5)));
-      let (a17_1_7, c17_1_7) = u8_add(u8_from_field_unsafe(to_field(a17_0_7) + to_field(c17_0_6)), u8_from_field_unsafe(to_field(a17_0_7) + to_field(c17_0_6)));
-      let b17 = [u8_from_field_unsafe(to_field(a17_1_0) + to_field(c17_1_7)), u8_from_field_unsafe(to_field(a17_1_1) + to_field(c17_1_0)), u8_from_field_unsafe(to_field(a17_1_2) + to_field(c17_1_1)), u8_from_field_unsafe(to_field(a17_1_3) + to_field(c17_1_2)), u8_from_field_unsafe(to_field(a17_1_4) + to_field(c17_1_3)), u8_from_field_unsafe(to_field(a17_1_5) + to_field(c17_1_4)), u8_from_field_unsafe(to_field(a17_1_6) + to_field(c17_1_5)), u8_from_field_unsafe(to_field(a17_1_7) + to_field(c17_1_6))];
-      -- b2 = rotl(t12, 43) = byte-rotl 5 + 3x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a2_0_0, c2_0_0) = u8_add(t12[3], t12[3]);
-      let (a2_0_1, c2_0_1) = u8_add(t12[4], t12[4]);
-      let (a2_0_2, c2_0_2) = u8_add(t12[5], t12[5]);
-      let (a2_0_3, c2_0_3) = u8_add(t12[6], t12[6]);
-      let (a2_0_4, c2_0_4) = u8_add(t12[7], t12[7]);
-      let (a2_0_5, c2_0_5) = u8_add(t12[0], t12[0]);
-      let (a2_0_6, c2_0_6) = u8_add(t12[1], t12[1]);
-      let (a2_0_7, c2_0_7) = u8_add(t12[2], t12[2]);
-      let (a2_1_0, c2_1_0) = u8_add(u8_from_field_unsafe(to_field(a2_0_0) + to_field(c2_0_7)), u8_from_field_unsafe(to_field(a2_0_0) + to_field(c2_0_7)));
-      let (a2_1_1, c2_1_1) = u8_add(u8_from_field_unsafe(to_field(a2_0_1) + to_field(c2_0_0)), u8_from_field_unsafe(to_field(a2_0_1) + to_field(c2_0_0)));
-      let (a2_1_2, c2_1_2) = u8_add(u8_from_field_unsafe(to_field(a2_0_2) + to_field(c2_0_1)), u8_from_field_unsafe(to_field(a2_0_2) + to_field(c2_0_1)));
-      let (a2_1_3, c2_1_3) = u8_add(u8_from_field_unsafe(to_field(a2_0_3) + to_field(c2_0_2)), u8_from_field_unsafe(to_field(a2_0_3) + to_field(c2_0_2)));
-      let (a2_1_4, c2_1_4) = u8_add(u8_from_field_unsafe(to_field(a2_0_4) + to_field(c2_0_3)), u8_from_field_unsafe(to_field(a2_0_4) + to_field(c2_0_3)));
-      let (a2_1_5, c2_1_5) = u8_add(u8_from_field_unsafe(to_field(a2_0_5) + to_field(c2_0_4)), u8_from_field_unsafe(to_field(a2_0_5) + to_field(c2_0_4)));
-      let (a2_1_6, c2_1_6) = u8_add(u8_from_field_unsafe(to_field(a2_0_6) + to_field(c2_0_5)), u8_from_field_unsafe(to_field(a2_0_6) + to_field(c2_0_5)));
-      let (a2_1_7, c2_1_7) = u8_add(u8_from_field_unsafe(to_field(a2_0_7) + to_field(c2_0_6)), u8_from_field_unsafe(to_field(a2_0_7) + to_field(c2_0_6)));
-      let (a2_2_0, c2_2_0) = u8_add(u8_from_field_unsafe(to_field(a2_1_0) + to_field(c2_1_7)), u8_from_field_unsafe(to_field(a2_1_0) + to_field(c2_1_7)));
-      let (a2_2_1, c2_2_1) = u8_add(u8_from_field_unsafe(to_field(a2_1_1) + to_field(c2_1_0)), u8_from_field_unsafe(to_field(a2_1_1) + to_field(c2_1_0)));
-      let (a2_2_2, c2_2_2) = u8_add(u8_from_field_unsafe(to_field(a2_1_2) + to_field(c2_1_1)), u8_from_field_unsafe(to_field(a2_1_2) + to_field(c2_1_1)));
-      let (a2_2_3, c2_2_3) = u8_add(u8_from_field_unsafe(to_field(a2_1_3) + to_field(c2_1_2)), u8_from_field_unsafe(to_field(a2_1_3) + to_field(c2_1_2)));
-      let (a2_2_4, c2_2_4) = u8_add(u8_from_field_unsafe(to_field(a2_1_4) + to_field(c2_1_3)), u8_from_field_unsafe(to_field(a2_1_4) + to_field(c2_1_3)));
-      let (a2_2_5, c2_2_5) = u8_add(u8_from_field_unsafe(to_field(a2_1_5) + to_field(c2_1_4)), u8_from_field_unsafe(to_field(a2_1_5) + to_field(c2_1_4)));
-      let (a2_2_6, c2_2_6) = u8_add(u8_from_field_unsafe(to_field(a2_1_6) + to_field(c2_1_5)), u8_from_field_unsafe(to_field(a2_1_6) + to_field(c2_1_5)));
-      let (a2_2_7, c2_2_7) = u8_add(u8_from_field_unsafe(to_field(a2_1_7) + to_field(c2_1_6)), u8_from_field_unsafe(to_field(a2_1_7) + to_field(c2_1_6)));
-      let b2 = [u8_from_field_unsafe(to_field(a2_2_0) + to_field(c2_2_7)), u8_from_field_unsafe(to_field(a2_2_1) + to_field(c2_2_0)), u8_from_field_unsafe(to_field(a2_2_2) + to_field(c2_2_1)), u8_from_field_unsafe(to_field(a2_2_3) + to_field(c2_2_2)), u8_from_field_unsafe(to_field(a2_2_4) + to_field(c2_2_3)), u8_from_field_unsafe(to_field(a2_2_5) + to_field(c2_2_4)), u8_from_field_unsafe(to_field(a2_2_6) + to_field(c2_2_5)), u8_from_field_unsafe(to_field(a2_2_7) + to_field(c2_2_6))];
-      -- b12 = rotl(t13, 25) = byte-rotl 3 + 1x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a12_0_0, c12_0_0) = u8_add(t13[5], t13[5]);
-      let (a12_0_1, c12_0_1) = u8_add(t13[6], t13[6]);
-      let (a12_0_2, c12_0_2) = u8_add(t13[7], t13[7]);
-      let (a12_0_3, c12_0_3) = u8_add(t13[0], t13[0]);
-      let (a12_0_4, c12_0_4) = u8_add(t13[1], t13[1]);
-      let (a12_0_5, c12_0_5) = u8_add(t13[2], t13[2]);
-      let (a12_0_6, c12_0_6) = u8_add(t13[3], t13[3]);
-      let (a12_0_7, c12_0_7) = u8_add(t13[4], t13[4]);
-      let b12 = [u8_from_field_unsafe(to_field(a12_0_0) + to_field(c12_0_7)), u8_from_field_unsafe(to_field(a12_0_1) + to_field(c12_0_0)), u8_from_field_unsafe(to_field(a12_0_2) + to_field(c12_0_1)), u8_from_field_unsafe(to_field(a12_0_3) + to_field(c12_0_2)), u8_from_field_unsafe(to_field(a12_0_4) + to_field(c12_0_3)), u8_from_field_unsafe(to_field(a12_0_5) + to_field(c12_0_4)), u8_from_field_unsafe(to_field(a12_0_6) + to_field(c12_0_5)), u8_from_field_unsafe(to_field(a12_0_7) + to_field(c12_0_6))];
-      -- b22 = rotl(t14, 39) = byte-rotl 5 + 1x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h22_0_0 = u8_shift_right(t14[3]);
-      let h22_0_1 = u8_shift_right(t14[4]);
-      let h22_0_2 = u8_shift_right(t14[5]);
-      let h22_0_3 = u8_shift_right(t14[6]);
-      let h22_0_4 = u8_shift_right(t14[7]);
-      let h22_0_5 = u8_shift_right(t14[0]);
-      let h22_0_6 = u8_shift_right(t14[1]);
-      let h22_0_7 = u8_shift_right(t14[2]);
-      let b22 = [u8_from_field_unsafe(to_field(h22_0_0) + 128 * (to_field(t14[4]) - 2 * to_field(h22_0_1))), u8_from_field_unsafe(to_field(h22_0_1) + 128 * (to_field(t14[5]) - 2 * to_field(h22_0_2))), u8_from_field_unsafe(to_field(h22_0_2) + 128 * (to_field(t14[6]) - 2 * to_field(h22_0_3))), u8_from_field_unsafe(to_field(h22_0_3) + 128 * (to_field(t14[7]) - 2 * to_field(h22_0_4))), u8_from_field_unsafe(to_field(h22_0_4) + 128 * (to_field(t14[0]) - 2 * to_field(h22_0_5))), u8_from_field_unsafe(to_field(h22_0_5) + 128 * (to_field(t14[1]) - 2 * to_field(h22_0_6))), u8_from_field_unsafe(to_field(h22_0_6) + 128 * (to_field(t14[2]) - 2 * to_field(h22_0_7))), u8_from_field_unsafe(to_field(h22_0_7) + 128 * (to_field(t14[3]) - 2 * to_field(h22_0_0)))];
-      -- b23 = rotl(t15, 41) = byte-rotl 5 + 1x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a23_0_0, c23_0_0) = u8_add(t15[3], t15[3]);
-      let (a23_0_1, c23_0_1) = u8_add(t15[4], t15[4]);
-      let (a23_0_2, c23_0_2) = u8_add(t15[5], t15[5]);
-      let (a23_0_3, c23_0_3) = u8_add(t15[6], t15[6]);
-      let (a23_0_4, c23_0_4) = u8_add(t15[7], t15[7]);
-      let (a23_0_5, c23_0_5) = u8_add(t15[0], t15[0]);
-      let (a23_0_6, c23_0_6) = u8_add(t15[1], t15[1]);
-      let (a23_0_7, c23_0_7) = u8_add(t15[2], t15[2]);
-      let b23 = [u8_from_field_unsafe(to_field(a23_0_0) + to_field(c23_0_7)), u8_from_field_unsafe(to_field(a23_0_1) + to_field(c23_0_0)), u8_from_field_unsafe(to_field(a23_0_2) + to_field(c23_0_1)), u8_from_field_unsafe(to_field(a23_0_3) + to_field(c23_0_2)), u8_from_field_unsafe(to_field(a23_0_4) + to_field(c23_0_3)), u8_from_field_unsafe(to_field(a23_0_5) + to_field(c23_0_4)), u8_from_field_unsafe(to_field(a23_0_6) + to_field(c23_0_5)), u8_from_field_unsafe(to_field(a23_0_7) + to_field(c23_0_6))];
-      -- b8 = rotl(t16, 45) = byte-rotl 6 + 3x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h8_0_0 = u8_shift_right(t16[2]);
-      let h8_0_1 = u8_shift_right(t16[3]);
-      let h8_0_2 = u8_shift_right(t16[4]);
-      let h8_0_3 = u8_shift_right(t16[5]);
-      let h8_0_4 = u8_shift_right(t16[6]);
-      let h8_0_5 = u8_shift_right(t16[7]);
-      let h8_0_6 = u8_shift_right(t16[0]);
-      let h8_0_7 = u8_shift_right(t16[1]);
-      let h8_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0) + 128 * (to_field(t16[3]) - 2 * to_field(h8_0_1))));
-      let h8_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1) + 128 * (to_field(t16[4]) - 2 * to_field(h8_0_2))));
-      let h8_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_2) + 128 * (to_field(t16[5]) - 2 * to_field(h8_0_3))));
-      let h8_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_3) + 128 * (to_field(t16[6]) - 2 * to_field(h8_0_4))));
-      let h8_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_4) + 128 * (to_field(t16[7]) - 2 * to_field(h8_0_5))));
-      let h8_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_5) + 128 * (to_field(t16[0]) - 2 * to_field(h8_0_6))));
-      let h8_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_6) + 128 * (to_field(t16[1]) - 2 * to_field(h8_0_7))));
-      let h8_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_7) + 128 * (to_field(t16[2]) - 2 * to_field(h8_0_0))));
-      let h8_2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1) + 128 * (to_field(t16[4]) - 2 * to_field(h8_0_2)))) - 2 * to_field(h8_1_1))));
-      let h8_2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_2) + 128 * (to_field(t16[5]) - 2 * to_field(h8_0_3)))) - 2 * to_field(h8_1_2))));
-      let h8_2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_3) + 128 * (to_field(t16[6]) - 2 * to_field(h8_0_4)))) - 2 * to_field(h8_1_3))));
-      let h8_2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_4) + 128 * (to_field(t16[7]) - 2 * to_field(h8_0_5)))) - 2 * to_field(h8_1_4))));
-      let h8_2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_5) + 128 * (to_field(t16[0]) - 2 * to_field(h8_0_6)))) - 2 * to_field(h8_1_5))));
-      let h8_2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_6) + 128 * (to_field(t16[1]) - 2 * to_field(h8_0_7)))) - 2 * to_field(h8_1_6))));
-      let h8_2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_7) + 128 * (to_field(t16[2]) - 2 * to_field(h8_0_0)))) - 2 * to_field(h8_1_7))));
-      let h8_2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h8_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0) + 128 * (to_field(t16[3]) - 2 * to_field(h8_0_1)))) - 2 * to_field(h8_1_0))));
-      let b8 = [u8_from_field_unsafe(to_field(h8_2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_2) + 128 * (to_field(t16[5]) - 2 * to_field(h8_0_3)))) - 2 * to_field(h8_1_2)))) - 2 * to_field(h8_2_1))), u8_from_field_unsafe(to_field(h8_2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_3) + 128 * (to_field(t16[6]) - 2 * to_field(h8_0_4)))) - 2 * to_field(h8_1_3)))) - 2 * to_field(h8_2_2))), u8_from_field_unsafe(to_field(h8_2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_4) + 128 * (to_field(t16[7]) - 2 * to_field(h8_0_5)))) - 2 * to_field(h8_1_4)))) - 2 * to_field(h8_2_3))), u8_from_field_unsafe(to_field(h8_2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_5) + 128 * (to_field(t16[0]) - 2 * to_field(h8_0_6)))) - 2 * to_field(h8_1_5)))) - 2 * to_field(h8_2_4))), u8_from_field_unsafe(to_field(h8_2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_6) + 128 * (to_field(t16[1]) - 2 * to_field(h8_0_7)))) - 2 * to_field(h8_1_6)))) - 2 * to_field(h8_2_5))), u8_from_field_unsafe(to_field(h8_2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_7) + 128 * (to_field(t16[2]) - 2 * to_field(h8_0_0)))) - 2 * to_field(h8_1_7)))) - 2 * to_field(h8_2_6))), u8_from_field_unsafe(to_field(h8_2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0) + 128 * (to_field(t16[3]) - 2 * to_field(h8_0_1)))) - 2 * to_field(h8_1_0)))) - 2 * to_field(h8_2_7))), u8_from_field_unsafe(to_field(h8_2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1) + 128 * (to_field(t16[4]) - 2 * to_field(h8_0_2)))) - 2 * to_field(h8_1_1)))) - 2 * to_field(h8_2_0)))];
-      -- b18 = rotl(t17, 15) = byte-rotl 2 + 1x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h18_0_0 = u8_shift_right(t17[6]);
-      let h18_0_1 = u8_shift_right(t17[7]);
-      let h18_0_2 = u8_shift_right(t17[0]);
-      let h18_0_3 = u8_shift_right(t17[1]);
-      let h18_0_4 = u8_shift_right(t17[2]);
-      let h18_0_5 = u8_shift_right(t17[3]);
-      let h18_0_6 = u8_shift_right(t17[4]);
-      let h18_0_7 = u8_shift_right(t17[5]);
-      let b18 = [u8_from_field_unsafe(to_field(h18_0_0) + 128 * (to_field(t17[7]) - 2 * to_field(h18_0_1))), u8_from_field_unsafe(to_field(h18_0_1) + 128 * (to_field(t17[0]) - 2 * to_field(h18_0_2))), u8_from_field_unsafe(to_field(h18_0_2) + 128 * (to_field(t17[1]) - 2 * to_field(h18_0_3))), u8_from_field_unsafe(to_field(h18_0_3) + 128 * (to_field(t17[2]) - 2 * to_field(h18_0_4))), u8_from_field_unsafe(to_field(h18_0_4) + 128 * (to_field(t17[3]) - 2 * to_field(h18_0_5))), u8_from_field_unsafe(to_field(h18_0_5) + 128 * (to_field(t17[4]) - 2 * to_field(h18_0_6))), u8_from_field_unsafe(to_field(h18_0_6) + 128 * (to_field(t17[5]) - 2 * to_field(h18_0_7))), u8_from_field_unsafe(to_field(h18_0_7) + 128 * (to_field(t17[6]) - 2 * to_field(h18_0_0)))];
-      -- b3 = rotl(t18, 21) = byte-rotl 3 + 3x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h3_0_0 = u8_shift_right(t18[5]);
-      let h3_0_1 = u8_shift_right(t18[6]);
-      let h3_0_2 = u8_shift_right(t18[7]);
-      let h3_0_3 = u8_shift_right(t18[0]);
-      let h3_0_4 = u8_shift_right(t18[1]);
-      let h3_0_5 = u8_shift_right(t18[2]);
-      let h3_0_6 = u8_shift_right(t18[3]);
-      let h3_0_7 = u8_shift_right(t18[4]);
-      let h3_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0) + 128 * (to_field(t18[6]) - 2 * to_field(h3_0_1))));
-      let h3_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1) + 128 * (to_field(t18[7]) - 2 * to_field(h3_0_2))));
-      let h3_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_2) + 128 * (to_field(t18[0]) - 2 * to_field(h3_0_3))));
-      let h3_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_3) + 128 * (to_field(t18[1]) - 2 * to_field(h3_0_4))));
-      let h3_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_4) + 128 * (to_field(t18[2]) - 2 * to_field(h3_0_5))));
-      let h3_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_5) + 128 * (to_field(t18[3]) - 2 * to_field(h3_0_6))));
-      let h3_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_6) + 128 * (to_field(t18[4]) - 2 * to_field(h3_0_7))));
-      let h3_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_7) + 128 * (to_field(t18[5]) - 2 * to_field(h3_0_0))));
-      let h3_2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1) + 128 * (to_field(t18[7]) - 2 * to_field(h3_0_2)))) - 2 * to_field(h3_1_1))));
-      let h3_2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_2) + 128 * (to_field(t18[0]) - 2 * to_field(h3_0_3)))) - 2 * to_field(h3_1_2))));
-      let h3_2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_3) + 128 * (to_field(t18[1]) - 2 * to_field(h3_0_4)))) - 2 * to_field(h3_1_3))));
-      let h3_2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_4) + 128 * (to_field(t18[2]) - 2 * to_field(h3_0_5)))) - 2 * to_field(h3_1_4))));
-      let h3_2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_5) + 128 * (to_field(t18[3]) - 2 * to_field(h3_0_6)))) - 2 * to_field(h3_1_5))));
-      let h3_2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_6) + 128 * (to_field(t18[4]) - 2 * to_field(h3_0_7)))) - 2 * to_field(h3_1_6))));
-      let h3_2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_7) + 128 * (to_field(t18[5]) - 2 * to_field(h3_0_0)))) - 2 * to_field(h3_1_7))));
-      let h3_2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h3_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0) + 128 * (to_field(t18[6]) - 2 * to_field(h3_0_1)))) - 2 * to_field(h3_1_0))));
-      let b3 = [u8_from_field_unsafe(to_field(h3_2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_2) + 128 * (to_field(t18[0]) - 2 * to_field(h3_0_3)))) - 2 * to_field(h3_1_2)))) - 2 * to_field(h3_2_1))), u8_from_field_unsafe(to_field(h3_2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_3) + 128 * (to_field(t18[1]) - 2 * to_field(h3_0_4)))) - 2 * to_field(h3_1_3)))) - 2 * to_field(h3_2_2))), u8_from_field_unsafe(to_field(h3_2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_4) + 128 * (to_field(t18[2]) - 2 * to_field(h3_0_5)))) - 2 * to_field(h3_1_4)))) - 2 * to_field(h3_2_3))), u8_from_field_unsafe(to_field(h3_2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_5) + 128 * (to_field(t18[3]) - 2 * to_field(h3_0_6)))) - 2 * to_field(h3_1_5)))) - 2 * to_field(h3_2_4))), u8_from_field_unsafe(to_field(h3_2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_6) + 128 * (to_field(t18[4]) - 2 * to_field(h3_0_7)))) - 2 * to_field(h3_1_6)))) - 2 * to_field(h3_2_5))), u8_from_field_unsafe(to_field(h3_2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_7) + 128 * (to_field(t18[5]) - 2 * to_field(h3_0_0)))) - 2 * to_field(h3_1_7)))) - 2 * to_field(h3_2_6))), u8_from_field_unsafe(to_field(h3_2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0) + 128 * (to_field(t18[6]) - 2 * to_field(h3_0_1)))) - 2 * to_field(h3_1_0)))) - 2 * to_field(h3_2_7))), u8_from_field_unsafe(to_field(h3_2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1) + 128 * (to_field(t18[7]) - 2 * to_field(h3_0_2)))) - 2 * to_field(h3_1_1)))) - 2 * to_field(h3_2_0)))];
-      -- b13 = rotl(t19, 8): byte rotation only (free)
-      let b13 = [t19[7], t19[0], t19[1], t19[2], t19[3], t19[4], t19[5], t19[6]];
-      -- b14 = rotl(t20, 18) = byte-rotl 2 + 2x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a14_0_0, c14_0_0) = u8_add(t20[6], t20[6]);
-      let (a14_0_1, c14_0_1) = u8_add(t20[7], t20[7]);
-      let (a14_0_2, c14_0_2) = u8_add(t20[0], t20[0]);
-      let (a14_0_3, c14_0_3) = u8_add(t20[1], t20[1]);
-      let (a14_0_4, c14_0_4) = u8_add(t20[2], t20[2]);
-      let (a14_0_5, c14_0_5) = u8_add(t20[3], t20[3]);
-      let (a14_0_6, c14_0_6) = u8_add(t20[4], t20[4]);
-      let (a14_0_7, c14_0_7) = u8_add(t20[5], t20[5]);
-      let (a14_1_0, c14_1_0) = u8_add(u8_from_field_unsafe(to_field(a14_0_0) + to_field(c14_0_7)), u8_from_field_unsafe(to_field(a14_0_0) + to_field(c14_0_7)));
-      let (a14_1_1, c14_1_1) = u8_add(u8_from_field_unsafe(to_field(a14_0_1) + to_field(c14_0_0)), u8_from_field_unsafe(to_field(a14_0_1) + to_field(c14_0_0)));
-      let (a14_1_2, c14_1_2) = u8_add(u8_from_field_unsafe(to_field(a14_0_2) + to_field(c14_0_1)), u8_from_field_unsafe(to_field(a14_0_2) + to_field(c14_0_1)));
-      let (a14_1_3, c14_1_3) = u8_add(u8_from_field_unsafe(to_field(a14_0_3) + to_field(c14_0_2)), u8_from_field_unsafe(to_field(a14_0_3) + to_field(c14_0_2)));
-      let (a14_1_4, c14_1_4) = u8_add(u8_from_field_unsafe(to_field(a14_0_4) + to_field(c14_0_3)), u8_from_field_unsafe(to_field(a14_0_4) + to_field(c14_0_3)));
-      let (a14_1_5, c14_1_5) = u8_add(u8_from_field_unsafe(to_field(a14_0_5) + to_field(c14_0_4)), u8_from_field_unsafe(to_field(a14_0_5) + to_field(c14_0_4)));
-      let (a14_1_6, c14_1_6) = u8_add(u8_from_field_unsafe(to_field(a14_0_6) + to_field(c14_0_5)), u8_from_field_unsafe(to_field(a14_0_6) + to_field(c14_0_5)));
-      let (a14_1_7, c14_1_7) = u8_add(u8_from_field_unsafe(to_field(a14_0_7) + to_field(c14_0_6)), u8_from_field_unsafe(to_field(a14_0_7) + to_field(c14_0_6)));
-      let b14 = [u8_from_field_unsafe(to_field(a14_1_0) + to_field(c14_1_7)), u8_from_field_unsafe(to_field(a14_1_1) + to_field(c14_1_0)), u8_from_field_unsafe(to_field(a14_1_2) + to_field(c14_1_1)), u8_from_field_unsafe(to_field(a14_1_3) + to_field(c14_1_2)), u8_from_field_unsafe(to_field(a14_1_4) + to_field(c14_1_3)), u8_from_field_unsafe(to_field(a14_1_5) + to_field(c14_1_4)), u8_from_field_unsafe(to_field(a14_1_6) + to_field(c14_1_5)), u8_from_field_unsafe(to_field(a14_1_7) + to_field(c14_1_6))];
-      -- b24 = rotl(t21, 2) = byte-rotl 0 + 2x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a24_0_0, c24_0_0) = u8_add(t21[0], t21[0]);
-      let (a24_0_1, c24_0_1) = u8_add(t21[1], t21[1]);
-      let (a24_0_2, c24_0_2) = u8_add(t21[2], t21[2]);
-      let (a24_0_3, c24_0_3) = u8_add(t21[3], t21[3]);
-      let (a24_0_4, c24_0_4) = u8_add(t21[4], t21[4]);
-      let (a24_0_5, c24_0_5) = u8_add(t21[5], t21[5]);
-      let (a24_0_6, c24_0_6) = u8_add(t21[6], t21[6]);
-      let (a24_0_7, c24_0_7) = u8_add(t21[7], t21[7]);
-      let (a24_1_0, c24_1_0) = u8_add(u8_from_field_unsafe(to_field(a24_0_0) + to_field(c24_0_7)), u8_from_field_unsafe(to_field(a24_0_0) + to_field(c24_0_7)));
-      let (a24_1_1, c24_1_1) = u8_add(u8_from_field_unsafe(to_field(a24_0_1) + to_field(c24_0_0)), u8_from_field_unsafe(to_field(a24_0_1) + to_field(c24_0_0)));
-      let (a24_1_2, c24_1_2) = u8_add(u8_from_field_unsafe(to_field(a24_0_2) + to_field(c24_0_1)), u8_from_field_unsafe(to_field(a24_0_2) + to_field(c24_0_1)));
-      let (a24_1_3, c24_1_3) = u8_add(u8_from_field_unsafe(to_field(a24_0_3) + to_field(c24_0_2)), u8_from_field_unsafe(to_field(a24_0_3) + to_field(c24_0_2)));
-      let (a24_1_4, c24_1_4) = u8_add(u8_from_field_unsafe(to_field(a24_0_4) + to_field(c24_0_3)), u8_from_field_unsafe(to_field(a24_0_4) + to_field(c24_0_3)));
-      let (a24_1_5, c24_1_5) = u8_add(u8_from_field_unsafe(to_field(a24_0_5) + to_field(c24_0_4)), u8_from_field_unsafe(to_field(a24_0_5) + to_field(c24_0_4)));
-      let (a24_1_6, c24_1_6) = u8_add(u8_from_field_unsafe(to_field(a24_0_6) + to_field(c24_0_5)), u8_from_field_unsafe(to_field(a24_0_6) + to_field(c24_0_5)));
-      let (a24_1_7, c24_1_7) = u8_add(u8_from_field_unsafe(to_field(a24_0_7) + to_field(c24_0_6)), u8_from_field_unsafe(to_field(a24_0_7) + to_field(c24_0_6)));
-      let b24 = [u8_from_field_unsafe(to_field(a24_1_0) + to_field(c24_1_7)), u8_from_field_unsafe(to_field(a24_1_1) + to_field(c24_1_0)), u8_from_field_unsafe(to_field(a24_1_2) + to_field(c24_1_1)), u8_from_field_unsafe(to_field(a24_1_3) + to_field(c24_1_2)), u8_from_field_unsafe(to_field(a24_1_4) + to_field(c24_1_3)), u8_from_field_unsafe(to_field(a24_1_5) + to_field(c24_1_4)), u8_from_field_unsafe(to_field(a24_1_6) + to_field(c24_1_5)), u8_from_field_unsafe(to_field(a24_1_7) + to_field(c24_1_6))];
-      -- b9 = rotl(t22, 61) = byte-rotl 8 + 3x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h9_0_0 = u8_shift_right(t22[0]);
-      let h9_0_1 = u8_shift_right(t22[1]);
-      let h9_0_2 = u8_shift_right(t22[2]);
-      let h9_0_3 = u8_shift_right(t22[3]);
-      let h9_0_4 = u8_shift_right(t22[4]);
-      let h9_0_5 = u8_shift_right(t22[5]);
-      let h9_0_6 = u8_shift_right(t22[6]);
-      let h9_0_7 = u8_shift_right(t22[7]);
-      let h9_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0) + 128 * (to_field(t22[1]) - 2 * to_field(h9_0_1))));
-      let h9_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1) + 128 * (to_field(t22[2]) - 2 * to_field(h9_0_2))));
-      let h9_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_2) + 128 * (to_field(t22[3]) - 2 * to_field(h9_0_3))));
-      let h9_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_3) + 128 * (to_field(t22[4]) - 2 * to_field(h9_0_4))));
-      let h9_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_4) + 128 * (to_field(t22[5]) - 2 * to_field(h9_0_5))));
-      let h9_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_5) + 128 * (to_field(t22[6]) - 2 * to_field(h9_0_6))));
-      let h9_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_6) + 128 * (to_field(t22[7]) - 2 * to_field(h9_0_7))));
-      let h9_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_7) + 128 * (to_field(t22[0]) - 2 * to_field(h9_0_0))));
-      let h9_2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1) + 128 * (to_field(t22[2]) - 2 * to_field(h9_0_2)))) - 2 * to_field(h9_1_1))));
-      let h9_2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_2) + 128 * (to_field(t22[3]) - 2 * to_field(h9_0_3)))) - 2 * to_field(h9_1_2))));
-      let h9_2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_3) + 128 * (to_field(t22[4]) - 2 * to_field(h9_0_4)))) - 2 * to_field(h9_1_3))));
-      let h9_2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_4) + 128 * (to_field(t22[5]) - 2 * to_field(h9_0_5)))) - 2 * to_field(h9_1_4))));
-      let h9_2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_5) + 128 * (to_field(t22[6]) - 2 * to_field(h9_0_6)))) - 2 * to_field(h9_1_5))));
-      let h9_2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_6) + 128 * (to_field(t22[7]) - 2 * to_field(h9_0_7)))) - 2 * to_field(h9_1_6))));
-      let h9_2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_7) + 128 * (to_field(t22[0]) - 2 * to_field(h9_0_0)))) - 2 * to_field(h9_1_7))));
-      let h9_2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h9_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0) + 128 * (to_field(t22[1]) - 2 * to_field(h9_0_1)))) - 2 * to_field(h9_1_0))));
-      let b9 = [u8_from_field_unsafe(to_field(h9_2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_2) + 128 * (to_field(t22[3]) - 2 * to_field(h9_0_3)))) - 2 * to_field(h9_1_2)))) - 2 * to_field(h9_2_1))), u8_from_field_unsafe(to_field(h9_2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_3) + 128 * (to_field(t22[4]) - 2 * to_field(h9_0_4)))) - 2 * to_field(h9_1_3)))) - 2 * to_field(h9_2_2))), u8_from_field_unsafe(to_field(h9_2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_4) + 128 * (to_field(t22[5]) - 2 * to_field(h9_0_5)))) - 2 * to_field(h9_1_4)))) - 2 * to_field(h9_2_3))), u8_from_field_unsafe(to_field(h9_2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_5) + 128 * (to_field(t22[6]) - 2 * to_field(h9_0_6)))) - 2 * to_field(h9_1_5)))) - 2 * to_field(h9_2_4))), u8_from_field_unsafe(to_field(h9_2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_6) + 128 * (to_field(t22[7]) - 2 * to_field(h9_0_7)))) - 2 * to_field(h9_1_6)))) - 2 * to_field(h9_2_5))), u8_from_field_unsafe(to_field(h9_2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_7) + 128 * (to_field(t22[0]) - 2 * to_field(h9_0_0)))) - 2 * to_field(h9_1_7)))) - 2 * to_field(h9_2_6))), u8_from_field_unsafe(to_field(h9_2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0) + 128 * (to_field(t22[1]) - 2 * to_field(h9_0_1)))) - 2 * to_field(h9_1_0)))) - 2 * to_field(h9_2_7))), u8_from_field_unsafe(to_field(h9_2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1) + 128 * (to_field(t22[2]) - 2 * to_field(h9_0_2)))) - 2 * to_field(h9_1_1)))) - 2 * to_field(h9_2_0)))];
-      -- b19 = rotl(t23, 56): byte rotation only (free)
-      let b19 = [t23[1], t23[2], t23[3], t23[4], t23[5], t23[6], t23[7], t23[0]];
-      -- b4 = rotl(t24, 14) = byte-rotl 2 + 2x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h4_0_0 = u8_shift_right(t24[6]);
-      let h4_0_1 = u8_shift_right(t24[7]);
-      let h4_0_2 = u8_shift_right(t24[0]);
-      let h4_0_3 = u8_shift_right(t24[1]);
-      let h4_0_4 = u8_shift_right(t24[2]);
-      let h4_0_5 = u8_shift_right(t24[3]);
-      let h4_0_6 = u8_shift_right(t24[4]);
-      let h4_0_7 = u8_shift_right(t24[5]);
-      let h4_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0) + 128 * (to_field(t24[7]) - 2 * to_field(h4_0_1))));
-      let h4_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_1) + 128 * (to_field(t24[0]) - 2 * to_field(h4_0_2))));
-      let h4_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_2) + 128 * (to_field(t24[1]) - 2 * to_field(h4_0_3))));
-      let h4_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_3) + 128 * (to_field(t24[2]) - 2 * to_field(h4_0_4))));
-      let h4_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_4) + 128 * (to_field(t24[3]) - 2 * to_field(h4_0_5))));
-      let h4_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_5) + 128 * (to_field(t24[4]) - 2 * to_field(h4_0_6))));
-      let h4_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_6) + 128 * (to_field(t24[5]) - 2 * to_field(h4_0_7))));
-      let h4_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_7) + 128 * (to_field(t24[6]) - 2 * to_field(h4_0_0))));
-      let b4 = [u8_from_field_unsafe(to_field(h4_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_1) + 128 * (to_field(t24[0]) - 2 * to_field(h4_0_2)))) - 2 * to_field(h4_1_1))), u8_from_field_unsafe(to_field(h4_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_2) + 128 * (to_field(t24[1]) - 2 * to_field(h4_0_3)))) - 2 * to_field(h4_1_2))), u8_from_field_unsafe(to_field(h4_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_3) + 128 * (to_field(t24[2]) - 2 * to_field(h4_0_4)))) - 2 * to_field(h4_1_3))), u8_from_field_unsafe(to_field(h4_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_4) + 128 * (to_field(t24[3]) - 2 * to_field(h4_0_5)))) - 2 * to_field(h4_1_4))), u8_from_field_unsafe(to_field(h4_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_5) + 128 * (to_field(t24[4]) - 2 * to_field(h4_0_6)))) - 2 * to_field(h4_1_5))), u8_from_field_unsafe(to_field(h4_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_6) + 128 * (to_field(t24[5]) - 2 * to_field(h4_0_7)))) - 2 * to_field(h4_1_6))), u8_from_field_unsafe(to_field(h4_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_7) + 128 * (to_field(t24[6]) - 2 * to_field(h4_0_0)))) - 2 * to_field(h4_1_7))), u8_from_field_unsafe(to_field(h4_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0) + 128 * (to_field(t24[7]) - 2 * to_field(h4_0_1)))) - 2 * to_field(h4_1_0)))];
-      -- chi: e[x,y] = b[x,y] ^ (~b[x+1,y] & b[x+2,y]); NOT is the free
-      -- recomposition 255 - b.
-      let e0 = [u8_xor(b0[0], u8_and(u8_from_field_unsafe(255 - to_field(b1[0])), b2[0])), u8_xor(b0[1], u8_and(u8_from_field_unsafe(255 - to_field(b1[1])), b2[1])), u8_xor(b0[2], u8_and(u8_from_field_unsafe(255 - to_field(b1[2])), b2[2])), u8_xor(b0[3], u8_and(u8_from_field_unsafe(255 - to_field(b1[3])), b2[3])), u8_xor(b0[4], u8_and(u8_from_field_unsafe(255 - to_field(b1[4])), b2[4])), u8_xor(b0[5], u8_and(u8_from_field_unsafe(255 - to_field(b1[5])), b2[5])), u8_xor(b0[6], u8_and(u8_from_field_unsafe(255 - to_field(b1[6])), b2[6])), u8_xor(b0[7], u8_and(u8_from_field_unsafe(255 - to_field(b1[7])), b2[7]))];
-      let e1 = [u8_xor(b1[0], u8_and(u8_from_field_unsafe(255 - to_field(b2[0])), b3[0])), u8_xor(b1[1], u8_and(u8_from_field_unsafe(255 - to_field(b2[1])), b3[1])), u8_xor(b1[2], u8_and(u8_from_field_unsafe(255 - to_field(b2[2])), b3[2])), u8_xor(b1[3], u8_and(u8_from_field_unsafe(255 - to_field(b2[3])), b3[3])), u8_xor(b1[4], u8_and(u8_from_field_unsafe(255 - to_field(b2[4])), b3[4])), u8_xor(b1[5], u8_and(u8_from_field_unsafe(255 - to_field(b2[5])), b3[5])), u8_xor(b1[6], u8_and(u8_from_field_unsafe(255 - to_field(b2[6])), b3[6])), u8_xor(b1[7], u8_and(u8_from_field_unsafe(255 - to_field(b2[7])), b3[7]))];
-      let e2 = [u8_xor(b2[0], u8_and(u8_from_field_unsafe(255 - to_field(b3[0])), b4[0])), u8_xor(b2[1], u8_and(u8_from_field_unsafe(255 - to_field(b3[1])), b4[1])), u8_xor(b2[2], u8_and(u8_from_field_unsafe(255 - to_field(b3[2])), b4[2])), u8_xor(b2[3], u8_and(u8_from_field_unsafe(255 - to_field(b3[3])), b4[3])), u8_xor(b2[4], u8_and(u8_from_field_unsafe(255 - to_field(b3[4])), b4[4])), u8_xor(b2[5], u8_and(u8_from_field_unsafe(255 - to_field(b3[5])), b4[5])), u8_xor(b2[6], u8_and(u8_from_field_unsafe(255 - to_field(b3[6])), b4[6])), u8_xor(b2[7], u8_and(u8_from_field_unsafe(255 - to_field(b3[7])), b4[7]))];
-      let e3 = [u8_xor(b3[0], u8_and(u8_from_field_unsafe(255 - to_field(b4[0])), b0[0])), u8_xor(b3[1], u8_and(u8_from_field_unsafe(255 - to_field(b4[1])), b0[1])), u8_xor(b3[2], u8_and(u8_from_field_unsafe(255 - to_field(b4[2])), b0[2])), u8_xor(b3[3], u8_and(u8_from_field_unsafe(255 - to_field(b4[3])), b0[3])), u8_xor(b3[4], u8_and(u8_from_field_unsafe(255 - to_field(b4[4])), b0[4])), u8_xor(b3[5], u8_and(u8_from_field_unsafe(255 - to_field(b4[5])), b0[5])), u8_xor(b3[6], u8_and(u8_from_field_unsafe(255 - to_field(b4[6])), b0[6])), u8_xor(b3[7], u8_and(u8_from_field_unsafe(255 - to_field(b4[7])), b0[7]))];
-      let e4 = [u8_xor(b4[0], u8_and(u8_from_field_unsafe(255 - to_field(b0[0])), b1[0])), u8_xor(b4[1], u8_and(u8_from_field_unsafe(255 - to_field(b0[1])), b1[1])), u8_xor(b4[2], u8_and(u8_from_field_unsafe(255 - to_field(b0[2])), b1[2])), u8_xor(b4[3], u8_and(u8_from_field_unsafe(255 - to_field(b0[3])), b1[3])), u8_xor(b4[4], u8_and(u8_from_field_unsafe(255 - to_field(b0[4])), b1[4])), u8_xor(b4[5], u8_and(u8_from_field_unsafe(255 - to_field(b0[5])), b1[5])), u8_xor(b4[6], u8_and(u8_from_field_unsafe(255 - to_field(b0[6])), b1[6])), u8_xor(b4[7], u8_and(u8_from_field_unsafe(255 - to_field(b0[7])), b1[7]))];
-      let e5 = [u8_xor(b5[0], u8_and(u8_from_field_unsafe(255 - to_field(b6[0])), b7[0])), u8_xor(b5[1], u8_and(u8_from_field_unsafe(255 - to_field(b6[1])), b7[1])), u8_xor(b5[2], u8_and(u8_from_field_unsafe(255 - to_field(b6[2])), b7[2])), u8_xor(b5[3], u8_and(u8_from_field_unsafe(255 - to_field(b6[3])), b7[3])), u8_xor(b5[4], u8_and(u8_from_field_unsafe(255 - to_field(b6[4])), b7[4])), u8_xor(b5[5], u8_and(u8_from_field_unsafe(255 - to_field(b6[5])), b7[5])), u8_xor(b5[6], u8_and(u8_from_field_unsafe(255 - to_field(b6[6])), b7[6])), u8_xor(b5[7], u8_and(u8_from_field_unsafe(255 - to_field(b6[7])), b7[7]))];
-      let e6 = [u8_xor(b6[0], u8_and(u8_from_field_unsafe(255 - to_field(b7[0])), b8[0])), u8_xor(b6[1], u8_and(u8_from_field_unsafe(255 - to_field(b7[1])), b8[1])), u8_xor(b6[2], u8_and(u8_from_field_unsafe(255 - to_field(b7[2])), b8[2])), u8_xor(b6[3], u8_and(u8_from_field_unsafe(255 - to_field(b7[3])), b8[3])), u8_xor(b6[4], u8_and(u8_from_field_unsafe(255 - to_field(b7[4])), b8[4])), u8_xor(b6[5], u8_and(u8_from_field_unsafe(255 - to_field(b7[5])), b8[5])), u8_xor(b6[6], u8_and(u8_from_field_unsafe(255 - to_field(b7[6])), b8[6])), u8_xor(b6[7], u8_and(u8_from_field_unsafe(255 - to_field(b7[7])), b8[7]))];
-      let e7 = [u8_xor(b7[0], u8_and(u8_from_field_unsafe(255 - to_field(b8[0])), b9[0])), u8_xor(b7[1], u8_and(u8_from_field_unsafe(255 - to_field(b8[1])), b9[1])), u8_xor(b7[2], u8_and(u8_from_field_unsafe(255 - to_field(b8[2])), b9[2])), u8_xor(b7[3], u8_and(u8_from_field_unsafe(255 - to_field(b8[3])), b9[3])), u8_xor(b7[4], u8_and(u8_from_field_unsafe(255 - to_field(b8[4])), b9[4])), u8_xor(b7[5], u8_and(u8_from_field_unsafe(255 - to_field(b8[5])), b9[5])), u8_xor(b7[6], u8_and(u8_from_field_unsafe(255 - to_field(b8[6])), b9[6])), u8_xor(b7[7], u8_and(u8_from_field_unsafe(255 - to_field(b8[7])), b9[7]))];
-      let e8 = [u8_xor(b8[0], u8_and(u8_from_field_unsafe(255 - to_field(b9[0])), b5[0])), u8_xor(b8[1], u8_and(u8_from_field_unsafe(255 - to_field(b9[1])), b5[1])), u8_xor(b8[2], u8_and(u8_from_field_unsafe(255 - to_field(b9[2])), b5[2])), u8_xor(b8[3], u8_and(u8_from_field_unsafe(255 - to_field(b9[3])), b5[3])), u8_xor(b8[4], u8_and(u8_from_field_unsafe(255 - to_field(b9[4])), b5[4])), u8_xor(b8[5], u8_and(u8_from_field_unsafe(255 - to_field(b9[5])), b5[5])), u8_xor(b8[6], u8_and(u8_from_field_unsafe(255 - to_field(b9[6])), b5[6])), u8_xor(b8[7], u8_and(u8_from_field_unsafe(255 - to_field(b9[7])), b5[7]))];
-      let e9 = [u8_xor(b9[0], u8_and(u8_from_field_unsafe(255 - to_field(b5[0])), b6[0])), u8_xor(b9[1], u8_and(u8_from_field_unsafe(255 - to_field(b5[1])), b6[1])), u8_xor(b9[2], u8_and(u8_from_field_unsafe(255 - to_field(b5[2])), b6[2])), u8_xor(b9[3], u8_and(u8_from_field_unsafe(255 - to_field(b5[3])), b6[3])), u8_xor(b9[4], u8_and(u8_from_field_unsafe(255 - to_field(b5[4])), b6[4])), u8_xor(b9[5], u8_and(u8_from_field_unsafe(255 - to_field(b5[5])), b6[5])), u8_xor(b9[6], u8_and(u8_from_field_unsafe(255 - to_field(b5[6])), b6[6])), u8_xor(b9[7], u8_and(u8_from_field_unsafe(255 - to_field(b5[7])), b6[7]))];
-      let e10 = [u8_xor(b10[0], u8_and(u8_from_field_unsafe(255 - to_field(b11[0])), b12[0])), u8_xor(b10[1], u8_and(u8_from_field_unsafe(255 - to_field(b11[1])), b12[1])), u8_xor(b10[2], u8_and(u8_from_field_unsafe(255 - to_field(b11[2])), b12[2])), u8_xor(b10[3], u8_and(u8_from_field_unsafe(255 - to_field(b11[3])), b12[3])), u8_xor(b10[4], u8_and(u8_from_field_unsafe(255 - to_field(b11[4])), b12[4])), u8_xor(b10[5], u8_and(u8_from_field_unsafe(255 - to_field(b11[5])), b12[5])), u8_xor(b10[6], u8_and(u8_from_field_unsafe(255 - to_field(b11[6])), b12[6])), u8_xor(b10[7], u8_and(u8_from_field_unsafe(255 - to_field(b11[7])), b12[7]))];
-      let e11 = [u8_xor(b11[0], u8_and(u8_from_field_unsafe(255 - to_field(b12[0])), b13[0])), u8_xor(b11[1], u8_and(u8_from_field_unsafe(255 - to_field(b12[1])), b13[1])), u8_xor(b11[2], u8_and(u8_from_field_unsafe(255 - to_field(b12[2])), b13[2])), u8_xor(b11[3], u8_and(u8_from_field_unsafe(255 - to_field(b12[3])), b13[3])), u8_xor(b11[4], u8_and(u8_from_field_unsafe(255 - to_field(b12[4])), b13[4])), u8_xor(b11[5], u8_and(u8_from_field_unsafe(255 - to_field(b12[5])), b13[5])), u8_xor(b11[6], u8_and(u8_from_field_unsafe(255 - to_field(b12[6])), b13[6])), u8_xor(b11[7], u8_and(u8_from_field_unsafe(255 - to_field(b12[7])), b13[7]))];
-      let e12 = [u8_xor(b12[0], u8_and(u8_from_field_unsafe(255 - to_field(b13[0])), b14[0])), u8_xor(b12[1], u8_and(u8_from_field_unsafe(255 - to_field(b13[1])), b14[1])), u8_xor(b12[2], u8_and(u8_from_field_unsafe(255 - to_field(b13[2])), b14[2])), u8_xor(b12[3], u8_and(u8_from_field_unsafe(255 - to_field(b13[3])), b14[3])), u8_xor(b12[4], u8_and(u8_from_field_unsafe(255 - to_field(b13[4])), b14[4])), u8_xor(b12[5], u8_and(u8_from_field_unsafe(255 - to_field(b13[5])), b14[5])), u8_xor(b12[6], u8_and(u8_from_field_unsafe(255 - to_field(b13[6])), b14[6])), u8_xor(b12[7], u8_and(u8_from_field_unsafe(255 - to_field(b13[7])), b14[7]))];
-      let e13 = [u8_xor(b13[0], u8_and(u8_from_field_unsafe(255 - to_field(b14[0])), b10[0])), u8_xor(b13[1], u8_and(u8_from_field_unsafe(255 - to_field(b14[1])), b10[1])), u8_xor(b13[2], u8_and(u8_from_field_unsafe(255 - to_field(b14[2])), b10[2])), u8_xor(b13[3], u8_and(u8_from_field_unsafe(255 - to_field(b14[3])), b10[3])), u8_xor(b13[4], u8_and(u8_from_field_unsafe(255 - to_field(b14[4])), b10[4])), u8_xor(b13[5], u8_and(u8_from_field_unsafe(255 - to_field(b14[5])), b10[5])), u8_xor(b13[6], u8_and(u8_from_field_unsafe(255 - to_field(b14[6])), b10[6])), u8_xor(b13[7], u8_and(u8_from_field_unsafe(255 - to_field(b14[7])), b10[7]))];
-      let e14 = [u8_xor(b14[0], u8_and(u8_from_field_unsafe(255 - to_field(b10[0])), b11[0])), u8_xor(b14[1], u8_and(u8_from_field_unsafe(255 - to_field(b10[1])), b11[1])), u8_xor(b14[2], u8_and(u8_from_field_unsafe(255 - to_field(b10[2])), b11[2])), u8_xor(b14[3], u8_and(u8_from_field_unsafe(255 - to_field(b10[3])), b11[3])), u8_xor(b14[4], u8_and(u8_from_field_unsafe(255 - to_field(b10[4])), b11[4])), u8_xor(b14[5], u8_and(u8_from_field_unsafe(255 - to_field(b10[5])), b11[5])), u8_xor(b14[6], u8_and(u8_from_field_unsafe(255 - to_field(b10[6])), b11[6])), u8_xor(b14[7], u8_and(u8_from_field_unsafe(255 - to_field(b10[7])), b11[7]))];
-      let e15 = [u8_xor(b15[0], u8_and(u8_from_field_unsafe(255 - to_field(b16[0])), b17[0])), u8_xor(b15[1], u8_and(u8_from_field_unsafe(255 - to_field(b16[1])), b17[1])), u8_xor(b15[2], u8_and(u8_from_field_unsafe(255 - to_field(b16[2])), b17[2])), u8_xor(b15[3], u8_and(u8_from_field_unsafe(255 - to_field(b16[3])), b17[3])), u8_xor(b15[4], u8_and(u8_from_field_unsafe(255 - to_field(b16[4])), b17[4])), u8_xor(b15[5], u8_and(u8_from_field_unsafe(255 - to_field(b16[5])), b17[5])), u8_xor(b15[6], u8_and(u8_from_field_unsafe(255 - to_field(b16[6])), b17[6])), u8_xor(b15[7], u8_and(u8_from_field_unsafe(255 - to_field(b16[7])), b17[7]))];
-      let e16 = [u8_xor(b16[0], u8_and(u8_from_field_unsafe(255 - to_field(b17[0])), b18[0])), u8_xor(b16[1], u8_and(u8_from_field_unsafe(255 - to_field(b17[1])), b18[1])), u8_xor(b16[2], u8_and(u8_from_field_unsafe(255 - to_field(b17[2])), b18[2])), u8_xor(b16[3], u8_and(u8_from_field_unsafe(255 - to_field(b17[3])), b18[3])), u8_xor(b16[4], u8_and(u8_from_field_unsafe(255 - to_field(b17[4])), b18[4])), u8_xor(b16[5], u8_and(u8_from_field_unsafe(255 - to_field(b17[5])), b18[5])), u8_xor(b16[6], u8_and(u8_from_field_unsafe(255 - to_field(b17[6])), b18[6])), u8_xor(b16[7], u8_and(u8_from_field_unsafe(255 - to_field(b17[7])), b18[7]))];
-      let e17 = [u8_xor(b17[0], u8_and(u8_from_field_unsafe(255 - to_field(b18[0])), b19[0])), u8_xor(b17[1], u8_and(u8_from_field_unsafe(255 - to_field(b18[1])), b19[1])), u8_xor(b17[2], u8_and(u8_from_field_unsafe(255 - to_field(b18[2])), b19[2])), u8_xor(b17[3], u8_and(u8_from_field_unsafe(255 - to_field(b18[3])), b19[3])), u8_xor(b17[4], u8_and(u8_from_field_unsafe(255 - to_field(b18[4])), b19[4])), u8_xor(b17[5], u8_and(u8_from_field_unsafe(255 - to_field(b18[5])), b19[5])), u8_xor(b17[6], u8_and(u8_from_field_unsafe(255 - to_field(b18[6])), b19[6])), u8_xor(b17[7], u8_and(u8_from_field_unsafe(255 - to_field(b18[7])), b19[7]))];
-      let e18 = [u8_xor(b18[0], u8_and(u8_from_field_unsafe(255 - to_field(b19[0])), b15[0])), u8_xor(b18[1], u8_and(u8_from_field_unsafe(255 - to_field(b19[1])), b15[1])), u8_xor(b18[2], u8_and(u8_from_field_unsafe(255 - to_field(b19[2])), b15[2])), u8_xor(b18[3], u8_and(u8_from_field_unsafe(255 - to_field(b19[3])), b15[3])), u8_xor(b18[4], u8_and(u8_from_field_unsafe(255 - to_field(b19[4])), b15[4])), u8_xor(b18[5], u8_and(u8_from_field_unsafe(255 - to_field(b19[5])), b15[5])), u8_xor(b18[6], u8_and(u8_from_field_unsafe(255 - to_field(b19[6])), b15[6])), u8_xor(b18[7], u8_and(u8_from_field_unsafe(255 - to_field(b19[7])), b15[7]))];
-      let e19 = [u8_xor(b19[0], u8_and(u8_from_field_unsafe(255 - to_field(b15[0])), b16[0])), u8_xor(b19[1], u8_and(u8_from_field_unsafe(255 - to_field(b15[1])), b16[1])), u8_xor(b19[2], u8_and(u8_from_field_unsafe(255 - to_field(b15[2])), b16[2])), u8_xor(b19[3], u8_and(u8_from_field_unsafe(255 - to_field(b15[3])), b16[3])), u8_xor(b19[4], u8_and(u8_from_field_unsafe(255 - to_field(b15[4])), b16[4])), u8_xor(b19[5], u8_and(u8_from_field_unsafe(255 - to_field(b15[5])), b16[5])), u8_xor(b19[6], u8_and(u8_from_field_unsafe(255 - to_field(b15[6])), b16[6])), u8_xor(b19[7], u8_and(u8_from_field_unsafe(255 - to_field(b15[7])), b16[7]))];
-      let e20 = [u8_xor(b20[0], u8_and(u8_from_field_unsafe(255 - to_field(b21[0])), b22[0])), u8_xor(b20[1], u8_and(u8_from_field_unsafe(255 - to_field(b21[1])), b22[1])), u8_xor(b20[2], u8_and(u8_from_field_unsafe(255 - to_field(b21[2])), b22[2])), u8_xor(b20[3], u8_and(u8_from_field_unsafe(255 - to_field(b21[3])), b22[3])), u8_xor(b20[4], u8_and(u8_from_field_unsafe(255 - to_field(b21[4])), b22[4])), u8_xor(b20[5], u8_and(u8_from_field_unsafe(255 - to_field(b21[5])), b22[5])), u8_xor(b20[6], u8_and(u8_from_field_unsafe(255 - to_field(b21[6])), b22[6])), u8_xor(b20[7], u8_and(u8_from_field_unsafe(255 - to_field(b21[7])), b22[7]))];
-      let e21 = [u8_xor(b21[0], u8_and(u8_from_field_unsafe(255 - to_field(b22[0])), b23[0])), u8_xor(b21[1], u8_and(u8_from_field_unsafe(255 - to_field(b22[1])), b23[1])), u8_xor(b21[2], u8_and(u8_from_field_unsafe(255 - to_field(b22[2])), b23[2])), u8_xor(b21[3], u8_and(u8_from_field_unsafe(255 - to_field(b22[3])), b23[3])), u8_xor(b21[4], u8_and(u8_from_field_unsafe(255 - to_field(b22[4])), b23[4])), u8_xor(b21[5], u8_and(u8_from_field_unsafe(255 - to_field(b22[5])), b23[5])), u8_xor(b21[6], u8_and(u8_from_field_unsafe(255 - to_field(b22[6])), b23[6])), u8_xor(b21[7], u8_and(u8_from_field_unsafe(255 - to_field(b22[7])), b23[7]))];
-      let e22 = [u8_xor(b22[0], u8_and(u8_from_field_unsafe(255 - to_field(b23[0])), b24[0])), u8_xor(b22[1], u8_and(u8_from_field_unsafe(255 - to_field(b23[1])), b24[1])), u8_xor(b22[2], u8_and(u8_from_field_unsafe(255 - to_field(b23[2])), b24[2])), u8_xor(b22[3], u8_and(u8_from_field_unsafe(255 - to_field(b23[3])), b24[3])), u8_xor(b22[4], u8_and(u8_from_field_unsafe(255 - to_field(b23[4])), b24[4])), u8_xor(b22[5], u8_and(u8_from_field_unsafe(255 - to_field(b23[5])), b24[5])), u8_xor(b22[6], u8_and(u8_from_field_unsafe(255 - to_field(b23[6])), b24[6])), u8_xor(b22[7], u8_and(u8_from_field_unsafe(255 - to_field(b23[7])), b24[7]))];
-      let e23 = [u8_xor(b23[0], u8_and(u8_from_field_unsafe(255 - to_field(b24[0])), b20[0])), u8_xor(b23[1], u8_and(u8_from_field_unsafe(255 - to_field(b24[1])), b20[1])), u8_xor(b23[2], u8_and(u8_from_field_unsafe(255 - to_field(b24[2])), b20[2])), u8_xor(b23[3], u8_and(u8_from_field_unsafe(255 - to_field(b24[3])), b20[3])), u8_xor(b23[4], u8_and(u8_from_field_unsafe(255 - to_field(b24[4])), b20[4])), u8_xor(b23[5], u8_and(u8_from_field_unsafe(255 - to_field(b24[5])), b20[5])), u8_xor(b23[6], u8_and(u8_from_field_unsafe(255 - to_field(b24[6])), b20[6])), u8_xor(b23[7], u8_and(u8_from_field_unsafe(255 - to_field(b24[7])), b20[7]))];
-      let e24 = [u8_xor(b24[0], u8_and(u8_from_field_unsafe(255 - to_field(b20[0])), b21[0])), u8_xor(b24[1], u8_and(u8_from_field_unsafe(255 - to_field(b20[1])), b21[1])), u8_xor(b24[2], u8_and(u8_from_field_unsafe(255 - to_field(b20[2])), b21[2])), u8_xor(b24[3], u8_and(u8_from_field_unsafe(255 - to_field(b20[3])), b21[3])), u8_xor(b24[4], u8_and(u8_from_field_unsafe(255 - to_field(b20[4])), b21[4])), u8_xor(b24[5], u8_and(u8_from_field_unsafe(255 - to_field(b20[5])), b21[5])), u8_xor(b24[6], u8_and(u8_from_field_unsafe(255 - to_field(b20[6])), b21[6])), u8_xor(b24[7], u8_and(u8_from_field_unsafe(255 - to_field(b20[7])), b21[7]))];
-      -- iota: xor the round constant into lane (0,0).
-      let f0 = [u8_xor(e0[0], rc[0]), u8_xor(e0[1], rc[1]), u8_xor(e0[2], rc[2]), u8_xor(e0[3], rc[3]), u8_xor(e0[4], rc[4]), u8_xor(e0[5], rc[5]), u8_xor(e0[6], rc[6]), u8_xor(e0[7], rc[7])];
-      [f0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24]
+  fn keccak_roundN(s0: [[U8; 8]; 25], rc0: [U8; 8]) -> [[U8; 8]; 25] {
+      -- round 0: theta
+      let c0_0 = [u8_xor(s0[20][0], u8_xor(s0[15][0], u8_xor(s0[10][0], u8_xor(s0[5][0], s0[0][0])))), u8_xor(s0[20][1], u8_xor(s0[15][1], u8_xor(s0[10][1], u8_xor(s0[5][1], s0[0][1])))), u8_xor(s0[20][2], u8_xor(s0[15][2], u8_xor(s0[10][2], u8_xor(s0[5][2], s0[0][2])))), u8_xor(s0[20][3], u8_xor(s0[15][3], u8_xor(s0[10][3], u8_xor(s0[5][3], s0[0][3])))), u8_xor(s0[20][4], u8_xor(s0[15][4], u8_xor(s0[10][4], u8_xor(s0[5][4], s0[0][4])))), u8_xor(s0[20][5], u8_xor(s0[15][5], u8_xor(s0[10][5], u8_xor(s0[5][5], s0[0][5])))), u8_xor(s0[20][6], u8_xor(s0[15][6], u8_xor(s0[10][6], u8_xor(s0[5][6], s0[0][6])))), u8_xor(s0[20][7], u8_xor(s0[15][7], u8_xor(s0[10][7], u8_xor(s0[5][7], s0[0][7]))))];
+      let c1_0 = [u8_xor(s0[21][0], u8_xor(s0[16][0], u8_xor(s0[11][0], u8_xor(s0[6][0], s0[1][0])))), u8_xor(s0[21][1], u8_xor(s0[16][1], u8_xor(s0[11][1], u8_xor(s0[6][1], s0[1][1])))), u8_xor(s0[21][2], u8_xor(s0[16][2], u8_xor(s0[11][2], u8_xor(s0[6][2], s0[1][2])))), u8_xor(s0[21][3], u8_xor(s0[16][3], u8_xor(s0[11][3], u8_xor(s0[6][3], s0[1][3])))), u8_xor(s0[21][4], u8_xor(s0[16][4], u8_xor(s0[11][4], u8_xor(s0[6][4], s0[1][4])))), u8_xor(s0[21][5], u8_xor(s0[16][5], u8_xor(s0[11][5], u8_xor(s0[6][5], s0[1][5])))), u8_xor(s0[21][6], u8_xor(s0[16][6], u8_xor(s0[11][6], u8_xor(s0[6][6], s0[1][6])))), u8_xor(s0[21][7], u8_xor(s0[16][7], u8_xor(s0[11][7], u8_xor(s0[6][7], s0[1][7]))))];
+      let c2_0 = [u8_xor(s0[22][0], u8_xor(s0[17][0], u8_xor(s0[12][0], u8_xor(s0[7][0], s0[2][0])))), u8_xor(s0[22][1], u8_xor(s0[17][1], u8_xor(s0[12][1], u8_xor(s0[7][1], s0[2][1])))), u8_xor(s0[22][2], u8_xor(s0[17][2], u8_xor(s0[12][2], u8_xor(s0[7][2], s0[2][2])))), u8_xor(s0[22][3], u8_xor(s0[17][3], u8_xor(s0[12][3], u8_xor(s0[7][3], s0[2][3])))), u8_xor(s0[22][4], u8_xor(s0[17][4], u8_xor(s0[12][4], u8_xor(s0[7][4], s0[2][4])))), u8_xor(s0[22][5], u8_xor(s0[17][5], u8_xor(s0[12][5], u8_xor(s0[7][5], s0[2][5])))), u8_xor(s0[22][6], u8_xor(s0[17][6], u8_xor(s0[12][6], u8_xor(s0[7][6], s0[2][6])))), u8_xor(s0[22][7], u8_xor(s0[17][7], u8_xor(s0[12][7], u8_xor(s0[7][7], s0[2][7]))))];
+      let c3_0 = [u8_xor(s0[23][0], u8_xor(s0[18][0], u8_xor(s0[13][0], u8_xor(s0[8][0], s0[3][0])))), u8_xor(s0[23][1], u8_xor(s0[18][1], u8_xor(s0[13][1], u8_xor(s0[8][1], s0[3][1])))), u8_xor(s0[23][2], u8_xor(s0[18][2], u8_xor(s0[13][2], u8_xor(s0[8][2], s0[3][2])))), u8_xor(s0[23][3], u8_xor(s0[18][3], u8_xor(s0[13][3], u8_xor(s0[8][3], s0[3][3])))), u8_xor(s0[23][4], u8_xor(s0[18][4], u8_xor(s0[13][4], u8_xor(s0[8][4], s0[3][4])))), u8_xor(s0[23][5], u8_xor(s0[18][5], u8_xor(s0[13][5], u8_xor(s0[8][5], s0[3][5])))), u8_xor(s0[23][6], u8_xor(s0[18][6], u8_xor(s0[13][6], u8_xor(s0[8][6], s0[3][6])))), u8_xor(s0[23][7], u8_xor(s0[18][7], u8_xor(s0[13][7], u8_xor(s0[8][7], s0[3][7]))))];
+      let c4_0 = [u8_xor(s0[24][0], u8_xor(s0[19][0], u8_xor(s0[14][0], u8_xor(s0[9][0], s0[4][0])))), u8_xor(s0[24][1], u8_xor(s0[19][1], u8_xor(s0[14][1], u8_xor(s0[9][1], s0[4][1])))), u8_xor(s0[24][2], u8_xor(s0[19][2], u8_xor(s0[14][2], u8_xor(s0[9][2], s0[4][2])))), u8_xor(s0[24][3], u8_xor(s0[19][3], u8_xor(s0[14][3], u8_xor(s0[9][3], s0[4][3])))), u8_xor(s0[24][4], u8_xor(s0[19][4], u8_xor(s0[14][4], u8_xor(s0[9][4], s0[4][4])))), u8_xor(s0[24][5], u8_xor(s0[19][5], u8_xor(s0[14][5], u8_xor(s0[9][5], s0[4][5])))), u8_xor(s0[24][6], u8_xor(s0[19][6], u8_xor(s0[14][6], u8_xor(s0[9][6], s0[4][6])))), u8_xor(s0[24][7], u8_xor(s0[19][7], u8_xor(s0[14][7], u8_xor(s0[9][7], s0[4][7]))))];
+      let (l0_0_0, m0_0_0) = u8_add(c0_0[0], c0_0[0]);
+      let (l0_0_1, m0_0_1) = u8_add(c0_0[1], c0_0[1]);
+      let (l0_0_2, m0_0_2) = u8_add(c0_0[2], c0_0[2]);
+      let (l0_0_3, m0_0_3) = u8_add(c0_0[3], c0_0[3]);
+      let (l0_0_4, m0_0_4) = u8_add(c0_0[4], c0_0[4]);
+      let (l0_0_5, m0_0_5) = u8_add(c0_0[5], c0_0[5]);
+      let (l0_0_6, m0_0_6) = u8_add(c0_0[6], c0_0[6]);
+      let (l0_0_7, m0_0_7) = u8_add(c0_0[7], c0_0[7]);
+      let r0_0 = [u8_from_field_unsafe(to_field(l0_0_0) + to_field(m0_0_7)), u8_from_field_unsafe(to_field(l0_0_1) + to_field(m0_0_0)), u8_from_field_unsafe(to_field(l0_0_2) + to_field(m0_0_1)), u8_from_field_unsafe(to_field(l0_0_3) + to_field(m0_0_2)), u8_from_field_unsafe(to_field(l0_0_4) + to_field(m0_0_3)), u8_from_field_unsafe(to_field(l0_0_5) + to_field(m0_0_4)), u8_from_field_unsafe(to_field(l0_0_6) + to_field(m0_0_5)), u8_from_field_unsafe(to_field(l0_0_7) + to_field(m0_0_6))];
+      let (l1_0_0, m1_0_0) = u8_add(c1_0[0], c1_0[0]);
+      let (l1_0_1, m1_0_1) = u8_add(c1_0[1], c1_0[1]);
+      let (l1_0_2, m1_0_2) = u8_add(c1_0[2], c1_0[2]);
+      let (l1_0_3, m1_0_3) = u8_add(c1_0[3], c1_0[3]);
+      let (l1_0_4, m1_0_4) = u8_add(c1_0[4], c1_0[4]);
+      let (l1_0_5, m1_0_5) = u8_add(c1_0[5], c1_0[5]);
+      let (l1_0_6, m1_0_6) = u8_add(c1_0[6], c1_0[6]);
+      let (l1_0_7, m1_0_7) = u8_add(c1_0[7], c1_0[7]);
+      let r1_0 = [u8_from_field_unsafe(to_field(l1_0_0) + to_field(m1_0_7)), u8_from_field_unsafe(to_field(l1_0_1) + to_field(m1_0_0)), u8_from_field_unsafe(to_field(l1_0_2) + to_field(m1_0_1)), u8_from_field_unsafe(to_field(l1_0_3) + to_field(m1_0_2)), u8_from_field_unsafe(to_field(l1_0_4) + to_field(m1_0_3)), u8_from_field_unsafe(to_field(l1_0_5) + to_field(m1_0_4)), u8_from_field_unsafe(to_field(l1_0_6) + to_field(m1_0_5)), u8_from_field_unsafe(to_field(l1_0_7) + to_field(m1_0_6))];
+      let (l2_0_0, m2_0_0) = u8_add(c2_0[0], c2_0[0]);
+      let (l2_0_1, m2_0_1) = u8_add(c2_0[1], c2_0[1]);
+      let (l2_0_2, m2_0_2) = u8_add(c2_0[2], c2_0[2]);
+      let (l2_0_3, m2_0_3) = u8_add(c2_0[3], c2_0[3]);
+      let (l2_0_4, m2_0_4) = u8_add(c2_0[4], c2_0[4]);
+      let (l2_0_5, m2_0_5) = u8_add(c2_0[5], c2_0[5]);
+      let (l2_0_6, m2_0_6) = u8_add(c2_0[6], c2_0[6]);
+      let (l2_0_7, m2_0_7) = u8_add(c2_0[7], c2_0[7]);
+      let r2_0 = [u8_from_field_unsafe(to_field(l2_0_0) + to_field(m2_0_7)), u8_from_field_unsafe(to_field(l2_0_1) + to_field(m2_0_0)), u8_from_field_unsafe(to_field(l2_0_2) + to_field(m2_0_1)), u8_from_field_unsafe(to_field(l2_0_3) + to_field(m2_0_2)), u8_from_field_unsafe(to_field(l2_0_4) + to_field(m2_0_3)), u8_from_field_unsafe(to_field(l2_0_5) + to_field(m2_0_4)), u8_from_field_unsafe(to_field(l2_0_6) + to_field(m2_0_5)), u8_from_field_unsafe(to_field(l2_0_7) + to_field(m2_0_6))];
+      let (l3_0_0, m3_0_0) = u8_add(c3_0[0], c3_0[0]);
+      let (l3_0_1, m3_0_1) = u8_add(c3_0[1], c3_0[1]);
+      let (l3_0_2, m3_0_2) = u8_add(c3_0[2], c3_0[2]);
+      let (l3_0_3, m3_0_3) = u8_add(c3_0[3], c3_0[3]);
+      let (l3_0_4, m3_0_4) = u8_add(c3_0[4], c3_0[4]);
+      let (l3_0_5, m3_0_5) = u8_add(c3_0[5], c3_0[5]);
+      let (l3_0_6, m3_0_6) = u8_add(c3_0[6], c3_0[6]);
+      let (l3_0_7, m3_0_7) = u8_add(c3_0[7], c3_0[7]);
+      let r3_0 = [u8_from_field_unsafe(to_field(l3_0_0) + to_field(m3_0_7)), u8_from_field_unsafe(to_field(l3_0_1) + to_field(m3_0_0)), u8_from_field_unsafe(to_field(l3_0_2) + to_field(m3_0_1)), u8_from_field_unsafe(to_field(l3_0_3) + to_field(m3_0_2)), u8_from_field_unsafe(to_field(l3_0_4) + to_field(m3_0_3)), u8_from_field_unsafe(to_field(l3_0_5) + to_field(m3_0_4)), u8_from_field_unsafe(to_field(l3_0_6) + to_field(m3_0_5)), u8_from_field_unsafe(to_field(l3_0_7) + to_field(m3_0_6))];
+      let (l4_0_0, m4_0_0) = u8_add(c4_0[0], c4_0[0]);
+      let (l4_0_1, m4_0_1) = u8_add(c4_0[1], c4_0[1]);
+      let (l4_0_2, m4_0_2) = u8_add(c4_0[2], c4_0[2]);
+      let (l4_0_3, m4_0_3) = u8_add(c4_0[3], c4_0[3]);
+      let (l4_0_4, m4_0_4) = u8_add(c4_0[4], c4_0[4]);
+      let (l4_0_5, m4_0_5) = u8_add(c4_0[5], c4_0[5]);
+      let (l4_0_6, m4_0_6) = u8_add(c4_0[6], c4_0[6]);
+      let (l4_0_7, m4_0_7) = u8_add(c4_0[7], c4_0[7]);
+      let r4_0 = [u8_from_field_unsafe(to_field(l4_0_0) + to_field(m4_0_7)), u8_from_field_unsafe(to_field(l4_0_1) + to_field(m4_0_0)), u8_from_field_unsafe(to_field(l4_0_2) + to_field(m4_0_1)), u8_from_field_unsafe(to_field(l4_0_3) + to_field(m4_0_2)), u8_from_field_unsafe(to_field(l4_0_4) + to_field(m4_0_3)), u8_from_field_unsafe(to_field(l4_0_5) + to_field(m4_0_4)), u8_from_field_unsafe(to_field(l4_0_6) + to_field(m4_0_5)), u8_from_field_unsafe(to_field(l4_0_7) + to_field(m4_0_6))];
+      let dd0_0 = [u8_xor(c4_0[0], r1_0[0]), u8_xor(c4_0[1], r1_0[1]), u8_xor(c4_0[2], r1_0[2]), u8_xor(c4_0[3], r1_0[3]), u8_xor(c4_0[4], r1_0[4]), u8_xor(c4_0[5], r1_0[5]), u8_xor(c4_0[6], r1_0[6]), u8_xor(c4_0[7], r1_0[7])];
+      let dd1_0 = [u8_xor(c0_0[0], r2_0[0]), u8_xor(c0_0[1], r2_0[1]), u8_xor(c0_0[2], r2_0[2]), u8_xor(c0_0[3], r2_0[3]), u8_xor(c0_0[4], r2_0[4]), u8_xor(c0_0[5], r2_0[5]), u8_xor(c0_0[6], r2_0[6]), u8_xor(c0_0[7], r2_0[7])];
+      let dd2_0 = [u8_xor(c1_0[0], r3_0[0]), u8_xor(c1_0[1], r3_0[1]), u8_xor(c1_0[2], r3_0[2]), u8_xor(c1_0[3], r3_0[3]), u8_xor(c1_0[4], r3_0[4]), u8_xor(c1_0[5], r3_0[5]), u8_xor(c1_0[6], r3_0[6]), u8_xor(c1_0[7], r3_0[7])];
+      let dd3_0 = [u8_xor(c2_0[0], r4_0[0]), u8_xor(c2_0[1], r4_0[1]), u8_xor(c2_0[2], r4_0[2]), u8_xor(c2_0[3], r4_0[3]), u8_xor(c2_0[4], r4_0[4]), u8_xor(c2_0[5], r4_0[5]), u8_xor(c2_0[6], r4_0[6]), u8_xor(c2_0[7], r4_0[7])];
+      let dd4_0 = [u8_xor(c3_0[0], r0_0[0]), u8_xor(c3_0[1], r0_0[1]), u8_xor(c3_0[2], r0_0[2]), u8_xor(c3_0[3], r0_0[3]), u8_xor(c3_0[4], r0_0[4]), u8_xor(c3_0[5], r0_0[5]), u8_xor(c3_0[6], r0_0[6]), u8_xor(c3_0[7], r0_0[7])];
+      let t0_0 = [u8_xor(s0[0][0], dd0_0[0]), u8_xor(s0[0][1], dd0_0[1]), u8_xor(s0[0][2], dd0_0[2]), u8_xor(s0[0][3], dd0_0[3]), u8_xor(s0[0][4], dd0_0[4]), u8_xor(s0[0][5], dd0_0[5]), u8_xor(s0[0][6], dd0_0[6]), u8_xor(s0[0][7], dd0_0[7])];
+      let t1_0 = [u8_xor(s0[1][0], dd1_0[0]), u8_xor(s0[1][1], dd1_0[1]), u8_xor(s0[1][2], dd1_0[2]), u8_xor(s0[1][3], dd1_0[3]), u8_xor(s0[1][4], dd1_0[4]), u8_xor(s0[1][5], dd1_0[5]), u8_xor(s0[1][6], dd1_0[6]), u8_xor(s0[1][7], dd1_0[7])];
+      let t2_0 = [u8_xor(s0[2][0], dd2_0[0]), u8_xor(s0[2][1], dd2_0[1]), u8_xor(s0[2][2], dd2_0[2]), u8_xor(s0[2][3], dd2_0[3]), u8_xor(s0[2][4], dd2_0[4]), u8_xor(s0[2][5], dd2_0[5]), u8_xor(s0[2][6], dd2_0[6]), u8_xor(s0[2][7], dd2_0[7])];
+      let t3_0 = [u8_xor(s0[3][0], dd3_0[0]), u8_xor(s0[3][1], dd3_0[1]), u8_xor(s0[3][2], dd3_0[2]), u8_xor(s0[3][3], dd3_0[3]), u8_xor(s0[3][4], dd3_0[4]), u8_xor(s0[3][5], dd3_0[5]), u8_xor(s0[3][6], dd3_0[6]), u8_xor(s0[3][7], dd3_0[7])];
+      let t4_0 = [u8_xor(s0[4][0], dd4_0[0]), u8_xor(s0[4][1], dd4_0[1]), u8_xor(s0[4][2], dd4_0[2]), u8_xor(s0[4][3], dd4_0[3]), u8_xor(s0[4][4], dd4_0[4]), u8_xor(s0[4][5], dd4_0[5]), u8_xor(s0[4][6], dd4_0[6]), u8_xor(s0[4][7], dd4_0[7])];
+      let t5_0 = [u8_xor(s0[5][0], dd0_0[0]), u8_xor(s0[5][1], dd0_0[1]), u8_xor(s0[5][2], dd0_0[2]), u8_xor(s0[5][3], dd0_0[3]), u8_xor(s0[5][4], dd0_0[4]), u8_xor(s0[5][5], dd0_0[5]), u8_xor(s0[5][6], dd0_0[6]), u8_xor(s0[5][7], dd0_0[7])];
+      let t6_0 = [u8_xor(s0[6][0], dd1_0[0]), u8_xor(s0[6][1], dd1_0[1]), u8_xor(s0[6][2], dd1_0[2]), u8_xor(s0[6][3], dd1_0[3]), u8_xor(s0[6][4], dd1_0[4]), u8_xor(s0[6][5], dd1_0[5]), u8_xor(s0[6][6], dd1_0[6]), u8_xor(s0[6][7], dd1_0[7])];
+      let t7_0 = [u8_xor(s0[7][0], dd2_0[0]), u8_xor(s0[7][1], dd2_0[1]), u8_xor(s0[7][2], dd2_0[2]), u8_xor(s0[7][3], dd2_0[3]), u8_xor(s0[7][4], dd2_0[4]), u8_xor(s0[7][5], dd2_0[5]), u8_xor(s0[7][6], dd2_0[6]), u8_xor(s0[7][7], dd2_0[7])];
+      let t8_0 = [u8_xor(s0[8][0], dd3_0[0]), u8_xor(s0[8][1], dd3_0[1]), u8_xor(s0[8][2], dd3_0[2]), u8_xor(s0[8][3], dd3_0[3]), u8_xor(s0[8][4], dd3_0[4]), u8_xor(s0[8][5], dd3_0[5]), u8_xor(s0[8][6], dd3_0[6]), u8_xor(s0[8][7], dd3_0[7])];
+      let t9_0 = [u8_xor(s0[9][0], dd4_0[0]), u8_xor(s0[9][1], dd4_0[1]), u8_xor(s0[9][2], dd4_0[2]), u8_xor(s0[9][3], dd4_0[3]), u8_xor(s0[9][4], dd4_0[4]), u8_xor(s0[9][5], dd4_0[5]), u8_xor(s0[9][6], dd4_0[6]), u8_xor(s0[9][7], dd4_0[7])];
+      let t10_0 = [u8_xor(s0[10][0], dd0_0[0]), u8_xor(s0[10][1], dd0_0[1]), u8_xor(s0[10][2], dd0_0[2]), u8_xor(s0[10][3], dd0_0[3]), u8_xor(s0[10][4], dd0_0[4]), u8_xor(s0[10][5], dd0_0[5]), u8_xor(s0[10][6], dd0_0[6]), u8_xor(s0[10][7], dd0_0[7])];
+      let t11_0 = [u8_xor(s0[11][0], dd1_0[0]), u8_xor(s0[11][1], dd1_0[1]), u8_xor(s0[11][2], dd1_0[2]), u8_xor(s0[11][3], dd1_0[3]), u8_xor(s0[11][4], dd1_0[4]), u8_xor(s0[11][5], dd1_0[5]), u8_xor(s0[11][6], dd1_0[6]), u8_xor(s0[11][7], dd1_0[7])];
+      let t12_0 = [u8_xor(s0[12][0], dd2_0[0]), u8_xor(s0[12][1], dd2_0[1]), u8_xor(s0[12][2], dd2_0[2]), u8_xor(s0[12][3], dd2_0[3]), u8_xor(s0[12][4], dd2_0[4]), u8_xor(s0[12][5], dd2_0[5]), u8_xor(s0[12][6], dd2_0[6]), u8_xor(s0[12][7], dd2_0[7])];
+      let t13_0 = [u8_xor(s0[13][0], dd3_0[0]), u8_xor(s0[13][1], dd3_0[1]), u8_xor(s0[13][2], dd3_0[2]), u8_xor(s0[13][3], dd3_0[3]), u8_xor(s0[13][4], dd3_0[4]), u8_xor(s0[13][5], dd3_0[5]), u8_xor(s0[13][6], dd3_0[6]), u8_xor(s0[13][7], dd3_0[7])];
+      let t14_0 = [u8_xor(s0[14][0], dd4_0[0]), u8_xor(s0[14][1], dd4_0[1]), u8_xor(s0[14][2], dd4_0[2]), u8_xor(s0[14][3], dd4_0[3]), u8_xor(s0[14][4], dd4_0[4]), u8_xor(s0[14][5], dd4_0[5]), u8_xor(s0[14][6], dd4_0[6]), u8_xor(s0[14][7], dd4_0[7])];
+      let t15_0 = [u8_xor(s0[15][0], dd0_0[0]), u8_xor(s0[15][1], dd0_0[1]), u8_xor(s0[15][2], dd0_0[2]), u8_xor(s0[15][3], dd0_0[3]), u8_xor(s0[15][4], dd0_0[4]), u8_xor(s0[15][5], dd0_0[5]), u8_xor(s0[15][6], dd0_0[6]), u8_xor(s0[15][7], dd0_0[7])];
+      let t16_0 = [u8_xor(s0[16][0], dd1_0[0]), u8_xor(s0[16][1], dd1_0[1]), u8_xor(s0[16][2], dd1_0[2]), u8_xor(s0[16][3], dd1_0[3]), u8_xor(s0[16][4], dd1_0[4]), u8_xor(s0[16][5], dd1_0[5]), u8_xor(s0[16][6], dd1_0[6]), u8_xor(s0[16][7], dd1_0[7])];
+      let t17_0 = [u8_xor(s0[17][0], dd2_0[0]), u8_xor(s0[17][1], dd2_0[1]), u8_xor(s0[17][2], dd2_0[2]), u8_xor(s0[17][3], dd2_0[3]), u8_xor(s0[17][4], dd2_0[4]), u8_xor(s0[17][5], dd2_0[5]), u8_xor(s0[17][6], dd2_0[6]), u8_xor(s0[17][7], dd2_0[7])];
+      let t18_0 = [u8_xor(s0[18][0], dd3_0[0]), u8_xor(s0[18][1], dd3_0[1]), u8_xor(s0[18][2], dd3_0[2]), u8_xor(s0[18][3], dd3_0[3]), u8_xor(s0[18][4], dd3_0[4]), u8_xor(s0[18][5], dd3_0[5]), u8_xor(s0[18][6], dd3_0[6]), u8_xor(s0[18][7], dd3_0[7])];
+      let t19_0 = [u8_xor(s0[19][0], dd4_0[0]), u8_xor(s0[19][1], dd4_0[1]), u8_xor(s0[19][2], dd4_0[2]), u8_xor(s0[19][3], dd4_0[3]), u8_xor(s0[19][4], dd4_0[4]), u8_xor(s0[19][5], dd4_0[5]), u8_xor(s0[19][6], dd4_0[6]), u8_xor(s0[19][7], dd4_0[7])];
+      let t20_0 = [u8_xor(s0[20][0], dd0_0[0]), u8_xor(s0[20][1], dd0_0[1]), u8_xor(s0[20][2], dd0_0[2]), u8_xor(s0[20][3], dd0_0[3]), u8_xor(s0[20][4], dd0_0[4]), u8_xor(s0[20][5], dd0_0[5]), u8_xor(s0[20][6], dd0_0[6]), u8_xor(s0[20][7], dd0_0[7])];
+      let t21_0 = [u8_xor(s0[21][0], dd1_0[0]), u8_xor(s0[21][1], dd1_0[1]), u8_xor(s0[21][2], dd1_0[2]), u8_xor(s0[21][3], dd1_0[3]), u8_xor(s0[21][4], dd1_0[4]), u8_xor(s0[21][5], dd1_0[5]), u8_xor(s0[21][6], dd1_0[6]), u8_xor(s0[21][7], dd1_0[7])];
+      let t22_0 = [u8_xor(s0[22][0], dd2_0[0]), u8_xor(s0[22][1], dd2_0[1]), u8_xor(s0[22][2], dd2_0[2]), u8_xor(s0[22][3], dd2_0[3]), u8_xor(s0[22][4], dd2_0[4]), u8_xor(s0[22][5], dd2_0[5]), u8_xor(s0[22][6], dd2_0[6]), u8_xor(s0[22][7], dd2_0[7])];
+      let t23_0 = [u8_xor(s0[23][0], dd3_0[0]), u8_xor(s0[23][1], dd3_0[1]), u8_xor(s0[23][2], dd3_0[2]), u8_xor(s0[23][3], dd3_0[3]), u8_xor(s0[23][4], dd3_0[4]), u8_xor(s0[23][5], dd3_0[5]), u8_xor(s0[23][6], dd3_0[6]), u8_xor(s0[23][7], dd3_0[7])];
+      let t24_0 = [u8_xor(s0[24][0], dd4_0[0]), u8_xor(s0[24][1], dd4_0[1]), u8_xor(s0[24][2], dd4_0[2]), u8_xor(s0[24][3], dd4_0[3]), u8_xor(s0[24][4], dd4_0[4]), u8_xor(s0[24][5], dd4_0[5]), u8_xor(s0[24][6], dd4_0[6]), u8_xor(s0[24][7], dd4_0[7])];
+      -- round 0: rho + pi
+      -- b0_0 = rotl(t0, 0): byte rotation only (free)
+      let b0_0 = [t0_0[0], t0_0[1], t0_0[2], t0_0[3], t0_0[4], t0_0[5], t0_0[6], t0_0[7]];
+      -- b10_0 = rotl(t1, 1) = byte-rotl 0 + 1x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a10_0_0_0, c10_0_0_0) = u8_add(t1_0[0], t1_0[0]);
+      let (a10_0_0_1, c10_0_0_1) = u8_add(t1_0[1], t1_0[1]);
+      let (a10_0_0_2, c10_0_0_2) = u8_add(t1_0[2], t1_0[2]);
+      let (a10_0_0_3, c10_0_0_3) = u8_add(t1_0[3], t1_0[3]);
+      let (a10_0_0_4, c10_0_0_4) = u8_add(t1_0[4], t1_0[4]);
+      let (a10_0_0_5, c10_0_0_5) = u8_add(t1_0[5], t1_0[5]);
+      let (a10_0_0_6, c10_0_0_6) = u8_add(t1_0[6], t1_0[6]);
+      let (a10_0_0_7, c10_0_0_7) = u8_add(t1_0[7], t1_0[7]);
+      let b10_0 = [u8_from_field_unsafe(to_field(a10_0_0_0) + to_field(c10_0_0_7)), u8_from_field_unsafe(to_field(a10_0_0_1) + to_field(c10_0_0_0)), u8_from_field_unsafe(to_field(a10_0_0_2) + to_field(c10_0_0_1)), u8_from_field_unsafe(to_field(a10_0_0_3) + to_field(c10_0_0_2)), u8_from_field_unsafe(to_field(a10_0_0_4) + to_field(c10_0_0_3)), u8_from_field_unsafe(to_field(a10_0_0_5) + to_field(c10_0_0_4)), u8_from_field_unsafe(to_field(a10_0_0_6) + to_field(c10_0_0_5)), u8_from_field_unsafe(to_field(a10_0_0_7) + to_field(c10_0_0_6))];
+      -- b20_0 = rotl(t2, 62) = byte-rotl 8 + 2x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h20_0_0_0 = u8_shift_right(t2_0[0]);
+      let h20_0_0_1 = u8_shift_right(t2_0[1]);
+      let h20_0_0_2 = u8_shift_right(t2_0[2]);
+      let h20_0_0_3 = u8_shift_right(t2_0[3]);
+      let h20_0_0_4 = u8_shift_right(t2_0[4]);
+      let h20_0_0_5 = u8_shift_right(t2_0[5]);
+      let h20_0_0_6 = u8_shift_right(t2_0[6]);
+      let h20_0_0_7 = u8_shift_right(t2_0[7]);
+      let h20_0_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_0) + 128 * (to_field(t2_0[1]) - 2 * to_field(h20_0_0_1))));
+      let h20_0_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_1) + 128 * (to_field(t2_0[2]) - 2 * to_field(h20_0_0_2))));
+      let h20_0_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_2) + 128 * (to_field(t2_0[3]) - 2 * to_field(h20_0_0_3))));
+      let h20_0_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_3) + 128 * (to_field(t2_0[4]) - 2 * to_field(h20_0_0_4))));
+      let h20_0_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_4) + 128 * (to_field(t2_0[5]) - 2 * to_field(h20_0_0_5))));
+      let h20_0_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_5) + 128 * (to_field(t2_0[6]) - 2 * to_field(h20_0_0_6))));
+      let h20_0_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_6) + 128 * (to_field(t2_0[7]) - 2 * to_field(h20_0_0_7))));
+      let h20_0_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_7) + 128 * (to_field(t2_0[0]) - 2 * to_field(h20_0_0_0))));
+      let b20_0 = [u8_from_field_unsafe(to_field(h20_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_1) + 128 * (to_field(t2_0[2]) - 2 * to_field(h20_0_0_2)))) - 2 * to_field(h20_0_1_1))), u8_from_field_unsafe(to_field(h20_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_2) + 128 * (to_field(t2_0[3]) - 2 * to_field(h20_0_0_3)))) - 2 * to_field(h20_0_1_2))), u8_from_field_unsafe(to_field(h20_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_3) + 128 * (to_field(t2_0[4]) - 2 * to_field(h20_0_0_4)))) - 2 * to_field(h20_0_1_3))), u8_from_field_unsafe(to_field(h20_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_4) + 128 * (to_field(t2_0[5]) - 2 * to_field(h20_0_0_5)))) - 2 * to_field(h20_0_1_4))), u8_from_field_unsafe(to_field(h20_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_5) + 128 * (to_field(t2_0[6]) - 2 * to_field(h20_0_0_6)))) - 2 * to_field(h20_0_1_5))), u8_from_field_unsafe(to_field(h20_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_6) + 128 * (to_field(t2_0[7]) - 2 * to_field(h20_0_0_7)))) - 2 * to_field(h20_0_1_6))), u8_from_field_unsafe(to_field(h20_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_7) + 128 * (to_field(t2_0[0]) - 2 * to_field(h20_0_0_0)))) - 2 * to_field(h20_0_1_7))), u8_from_field_unsafe(to_field(h20_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_0) + 128 * (to_field(t2_0[1]) - 2 * to_field(h20_0_0_1)))) - 2 * to_field(h20_0_1_0)))];
+      -- b5_0 = rotl(t3, 28) = byte-rotl 3 + bit-shl 4 (decomposition)
+      let d5_0_0 = u8_bit_decomposition(t3_0[0]);
+      let d5_0_1 = u8_bit_decomposition(t3_0[1]);
+      let d5_0_2 = u8_bit_decomposition(t3_0[2]);
+      let d5_0_3 = u8_bit_decomposition(t3_0[3]);
+      let d5_0_4 = u8_bit_decomposition(t3_0[4]);
+      let d5_0_5 = u8_bit_decomposition(t3_0[5]);
+      let d5_0_6 = u8_bit_decomposition(t3_0[6]);
+      let d5_0_7 = u8_bit_decomposition(t3_0[7]);
+      let b5_0 = [u8_from_field_unsafe(d5_0_4[4] + 2 * d5_0_4[5] + 4 * d5_0_4[6] + 8 * d5_0_4[7] + 16 * d5_0_5[0] + 32 * d5_0_5[1] + 64 * d5_0_5[2] + 128 * d5_0_5[3]), u8_from_field_unsafe(d5_0_5[4] + 2 * d5_0_5[5] + 4 * d5_0_5[6] + 8 * d5_0_5[7] + 16 * d5_0_6[0] + 32 * d5_0_6[1] + 64 * d5_0_6[2] + 128 * d5_0_6[3]), u8_from_field_unsafe(d5_0_6[4] + 2 * d5_0_6[5] + 4 * d5_0_6[6] + 8 * d5_0_6[7] + 16 * d5_0_7[0] + 32 * d5_0_7[1] + 64 * d5_0_7[2] + 128 * d5_0_7[3]), u8_from_field_unsafe(d5_0_7[4] + 2 * d5_0_7[5] + 4 * d5_0_7[6] + 8 * d5_0_7[7] + 16 * d5_0_0[0] + 32 * d5_0_0[1] + 64 * d5_0_0[2] + 128 * d5_0_0[3]), u8_from_field_unsafe(d5_0_0[4] + 2 * d5_0_0[5] + 4 * d5_0_0[6] + 8 * d5_0_0[7] + 16 * d5_0_1[0] + 32 * d5_0_1[1] + 64 * d5_0_1[2] + 128 * d5_0_1[3]), u8_from_field_unsafe(d5_0_1[4] + 2 * d5_0_1[5] + 4 * d5_0_1[6] + 8 * d5_0_1[7] + 16 * d5_0_2[0] + 32 * d5_0_2[1] + 64 * d5_0_2[2] + 128 * d5_0_2[3]), u8_from_field_unsafe(d5_0_2[4] + 2 * d5_0_2[5] + 4 * d5_0_2[6] + 8 * d5_0_2[7] + 16 * d5_0_3[0] + 32 * d5_0_3[1] + 64 * d5_0_3[2] + 128 * d5_0_3[3]), u8_from_field_unsafe(d5_0_3[4] + 2 * d5_0_3[5] + 4 * d5_0_3[6] + 8 * d5_0_3[7] + 16 * d5_0_4[0] + 32 * d5_0_4[1] + 64 * d5_0_4[2] + 128 * d5_0_4[3])];
+      -- b15_0 = rotl(t4, 27) = byte-rotl 3 + 3x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a15_0_0_0, c15_0_0_0) = u8_add(t4_0[5], t4_0[5]);
+      let (a15_0_0_1, c15_0_0_1) = u8_add(t4_0[6], t4_0[6]);
+      let (a15_0_0_2, c15_0_0_2) = u8_add(t4_0[7], t4_0[7]);
+      let (a15_0_0_3, c15_0_0_3) = u8_add(t4_0[0], t4_0[0]);
+      let (a15_0_0_4, c15_0_0_4) = u8_add(t4_0[1], t4_0[1]);
+      let (a15_0_0_5, c15_0_0_5) = u8_add(t4_0[2], t4_0[2]);
+      let (a15_0_0_6, c15_0_0_6) = u8_add(t4_0[3], t4_0[3]);
+      let (a15_0_0_7, c15_0_0_7) = u8_add(t4_0[4], t4_0[4]);
+      let (a15_0_1_0, c15_0_1_0) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_0) + to_field(c15_0_0_7)), u8_from_field_unsafe(to_field(a15_0_0_0) + to_field(c15_0_0_7)));
+      let (a15_0_1_1, c15_0_1_1) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_1) + to_field(c15_0_0_0)), u8_from_field_unsafe(to_field(a15_0_0_1) + to_field(c15_0_0_0)));
+      let (a15_0_1_2, c15_0_1_2) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_2) + to_field(c15_0_0_1)), u8_from_field_unsafe(to_field(a15_0_0_2) + to_field(c15_0_0_1)));
+      let (a15_0_1_3, c15_0_1_3) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_3) + to_field(c15_0_0_2)), u8_from_field_unsafe(to_field(a15_0_0_3) + to_field(c15_0_0_2)));
+      let (a15_0_1_4, c15_0_1_4) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_4) + to_field(c15_0_0_3)), u8_from_field_unsafe(to_field(a15_0_0_4) + to_field(c15_0_0_3)));
+      let (a15_0_1_5, c15_0_1_5) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_5) + to_field(c15_0_0_4)), u8_from_field_unsafe(to_field(a15_0_0_5) + to_field(c15_0_0_4)));
+      let (a15_0_1_6, c15_0_1_6) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_6) + to_field(c15_0_0_5)), u8_from_field_unsafe(to_field(a15_0_0_6) + to_field(c15_0_0_5)));
+      let (a15_0_1_7, c15_0_1_7) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_7) + to_field(c15_0_0_6)), u8_from_field_unsafe(to_field(a15_0_0_7) + to_field(c15_0_0_6)));
+      let (a15_0_2_0, c15_0_2_0) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_0) + to_field(c15_0_1_7)), u8_from_field_unsafe(to_field(a15_0_1_0) + to_field(c15_0_1_7)));
+      let (a15_0_2_1, c15_0_2_1) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_1) + to_field(c15_0_1_0)), u8_from_field_unsafe(to_field(a15_0_1_1) + to_field(c15_0_1_0)));
+      let (a15_0_2_2, c15_0_2_2) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_2) + to_field(c15_0_1_1)), u8_from_field_unsafe(to_field(a15_0_1_2) + to_field(c15_0_1_1)));
+      let (a15_0_2_3, c15_0_2_3) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_3) + to_field(c15_0_1_2)), u8_from_field_unsafe(to_field(a15_0_1_3) + to_field(c15_0_1_2)));
+      let (a15_0_2_4, c15_0_2_4) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_4) + to_field(c15_0_1_3)), u8_from_field_unsafe(to_field(a15_0_1_4) + to_field(c15_0_1_3)));
+      let (a15_0_2_5, c15_0_2_5) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_5) + to_field(c15_0_1_4)), u8_from_field_unsafe(to_field(a15_0_1_5) + to_field(c15_0_1_4)));
+      let (a15_0_2_6, c15_0_2_6) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_6) + to_field(c15_0_1_5)), u8_from_field_unsafe(to_field(a15_0_1_6) + to_field(c15_0_1_5)));
+      let (a15_0_2_7, c15_0_2_7) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_7) + to_field(c15_0_1_6)), u8_from_field_unsafe(to_field(a15_0_1_7) + to_field(c15_0_1_6)));
+      let b15_0 = [u8_from_field_unsafe(to_field(a15_0_2_0) + to_field(c15_0_2_7)), u8_from_field_unsafe(to_field(a15_0_2_1) + to_field(c15_0_2_0)), u8_from_field_unsafe(to_field(a15_0_2_2) + to_field(c15_0_2_1)), u8_from_field_unsafe(to_field(a15_0_2_3) + to_field(c15_0_2_2)), u8_from_field_unsafe(to_field(a15_0_2_4) + to_field(c15_0_2_3)), u8_from_field_unsafe(to_field(a15_0_2_5) + to_field(c15_0_2_4)), u8_from_field_unsafe(to_field(a15_0_2_6) + to_field(c15_0_2_5)), u8_from_field_unsafe(to_field(a15_0_2_7) + to_field(c15_0_2_6))];
+      -- b16_0 = rotl(t5, 36) = byte-rotl 4 + bit-shl 4 (decomposition)
+      let d16_0_0 = u8_bit_decomposition(t5_0[0]);
+      let d16_0_1 = u8_bit_decomposition(t5_0[1]);
+      let d16_0_2 = u8_bit_decomposition(t5_0[2]);
+      let d16_0_3 = u8_bit_decomposition(t5_0[3]);
+      let d16_0_4 = u8_bit_decomposition(t5_0[4]);
+      let d16_0_5 = u8_bit_decomposition(t5_0[5]);
+      let d16_0_6 = u8_bit_decomposition(t5_0[6]);
+      let d16_0_7 = u8_bit_decomposition(t5_0[7]);
+      let b16_0 = [u8_from_field_unsafe(d16_0_3[4] + 2 * d16_0_3[5] + 4 * d16_0_3[6] + 8 * d16_0_3[7] + 16 * d16_0_4[0] + 32 * d16_0_4[1] + 64 * d16_0_4[2] + 128 * d16_0_4[3]), u8_from_field_unsafe(d16_0_4[4] + 2 * d16_0_4[5] + 4 * d16_0_4[6] + 8 * d16_0_4[7] + 16 * d16_0_5[0] + 32 * d16_0_5[1] + 64 * d16_0_5[2] + 128 * d16_0_5[3]), u8_from_field_unsafe(d16_0_5[4] + 2 * d16_0_5[5] + 4 * d16_0_5[6] + 8 * d16_0_5[7] + 16 * d16_0_6[0] + 32 * d16_0_6[1] + 64 * d16_0_6[2] + 128 * d16_0_6[3]), u8_from_field_unsafe(d16_0_6[4] + 2 * d16_0_6[5] + 4 * d16_0_6[6] + 8 * d16_0_6[7] + 16 * d16_0_7[0] + 32 * d16_0_7[1] + 64 * d16_0_7[2] + 128 * d16_0_7[3]), u8_from_field_unsafe(d16_0_7[4] + 2 * d16_0_7[5] + 4 * d16_0_7[6] + 8 * d16_0_7[7] + 16 * d16_0_0[0] + 32 * d16_0_0[1] + 64 * d16_0_0[2] + 128 * d16_0_0[3]), u8_from_field_unsafe(d16_0_0[4] + 2 * d16_0_0[5] + 4 * d16_0_0[6] + 8 * d16_0_0[7] + 16 * d16_0_1[0] + 32 * d16_0_1[1] + 64 * d16_0_1[2] + 128 * d16_0_1[3]), u8_from_field_unsafe(d16_0_1[4] + 2 * d16_0_1[5] + 4 * d16_0_1[6] + 8 * d16_0_1[7] + 16 * d16_0_2[0] + 32 * d16_0_2[1] + 64 * d16_0_2[2] + 128 * d16_0_2[3]), u8_from_field_unsafe(d16_0_2[4] + 2 * d16_0_2[5] + 4 * d16_0_2[6] + 8 * d16_0_2[7] + 16 * d16_0_3[0] + 32 * d16_0_3[1] + 64 * d16_0_3[2] + 128 * d16_0_3[3])];
+      -- b1_0 = rotl(t6, 44) = byte-rotl 5 + bit-shl 4 (decomposition)
+      let d1_0_0 = u8_bit_decomposition(t6_0[0]);
+      let d1_0_1 = u8_bit_decomposition(t6_0[1]);
+      let d1_0_2 = u8_bit_decomposition(t6_0[2]);
+      let d1_0_3 = u8_bit_decomposition(t6_0[3]);
+      let d1_0_4 = u8_bit_decomposition(t6_0[4]);
+      let d1_0_5 = u8_bit_decomposition(t6_0[5]);
+      let d1_0_6 = u8_bit_decomposition(t6_0[6]);
+      let d1_0_7 = u8_bit_decomposition(t6_0[7]);
+      let b1_0 = [u8_from_field_unsafe(d1_0_2[4] + 2 * d1_0_2[5] + 4 * d1_0_2[6] + 8 * d1_0_2[7] + 16 * d1_0_3[0] + 32 * d1_0_3[1] + 64 * d1_0_3[2] + 128 * d1_0_3[3]), u8_from_field_unsafe(d1_0_3[4] + 2 * d1_0_3[5] + 4 * d1_0_3[6] + 8 * d1_0_3[7] + 16 * d1_0_4[0] + 32 * d1_0_4[1] + 64 * d1_0_4[2] + 128 * d1_0_4[3]), u8_from_field_unsafe(d1_0_4[4] + 2 * d1_0_4[5] + 4 * d1_0_4[6] + 8 * d1_0_4[7] + 16 * d1_0_5[0] + 32 * d1_0_5[1] + 64 * d1_0_5[2] + 128 * d1_0_5[3]), u8_from_field_unsafe(d1_0_5[4] + 2 * d1_0_5[5] + 4 * d1_0_5[6] + 8 * d1_0_5[7] + 16 * d1_0_6[0] + 32 * d1_0_6[1] + 64 * d1_0_6[2] + 128 * d1_0_6[3]), u8_from_field_unsafe(d1_0_6[4] + 2 * d1_0_6[5] + 4 * d1_0_6[6] + 8 * d1_0_6[7] + 16 * d1_0_7[0] + 32 * d1_0_7[1] + 64 * d1_0_7[2] + 128 * d1_0_7[3]), u8_from_field_unsafe(d1_0_7[4] + 2 * d1_0_7[5] + 4 * d1_0_7[6] + 8 * d1_0_7[7] + 16 * d1_0_0[0] + 32 * d1_0_0[1] + 64 * d1_0_0[2] + 128 * d1_0_0[3]), u8_from_field_unsafe(d1_0_0[4] + 2 * d1_0_0[5] + 4 * d1_0_0[6] + 8 * d1_0_0[7] + 16 * d1_0_1[0] + 32 * d1_0_1[1] + 64 * d1_0_1[2] + 128 * d1_0_1[3]), u8_from_field_unsafe(d1_0_1[4] + 2 * d1_0_1[5] + 4 * d1_0_1[6] + 8 * d1_0_1[7] + 16 * d1_0_2[0] + 32 * d1_0_2[1] + 64 * d1_0_2[2] + 128 * d1_0_2[3])];
+      -- b11_0 = rotl(t7, 6) = byte-rotl 1 + 2x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h11_0_0_0 = u8_shift_right(t7_0[7]);
+      let h11_0_0_1 = u8_shift_right(t7_0[0]);
+      let h11_0_0_2 = u8_shift_right(t7_0[1]);
+      let h11_0_0_3 = u8_shift_right(t7_0[2]);
+      let h11_0_0_4 = u8_shift_right(t7_0[3]);
+      let h11_0_0_5 = u8_shift_right(t7_0[4]);
+      let h11_0_0_6 = u8_shift_right(t7_0[5]);
+      let h11_0_0_7 = u8_shift_right(t7_0[6]);
+      let h11_0_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_0) + 128 * (to_field(t7_0[0]) - 2 * to_field(h11_0_0_1))));
+      let h11_0_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_1) + 128 * (to_field(t7_0[1]) - 2 * to_field(h11_0_0_2))));
+      let h11_0_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_2) + 128 * (to_field(t7_0[2]) - 2 * to_field(h11_0_0_3))));
+      let h11_0_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_3) + 128 * (to_field(t7_0[3]) - 2 * to_field(h11_0_0_4))));
+      let h11_0_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_4) + 128 * (to_field(t7_0[4]) - 2 * to_field(h11_0_0_5))));
+      let h11_0_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_5) + 128 * (to_field(t7_0[5]) - 2 * to_field(h11_0_0_6))));
+      let h11_0_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_6) + 128 * (to_field(t7_0[6]) - 2 * to_field(h11_0_0_7))));
+      let h11_0_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_7) + 128 * (to_field(t7_0[7]) - 2 * to_field(h11_0_0_0))));
+      let b11_0 = [u8_from_field_unsafe(to_field(h11_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_1) + 128 * (to_field(t7_0[1]) - 2 * to_field(h11_0_0_2)))) - 2 * to_field(h11_0_1_1))), u8_from_field_unsafe(to_field(h11_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_2) + 128 * (to_field(t7_0[2]) - 2 * to_field(h11_0_0_3)))) - 2 * to_field(h11_0_1_2))), u8_from_field_unsafe(to_field(h11_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_3) + 128 * (to_field(t7_0[3]) - 2 * to_field(h11_0_0_4)))) - 2 * to_field(h11_0_1_3))), u8_from_field_unsafe(to_field(h11_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_4) + 128 * (to_field(t7_0[4]) - 2 * to_field(h11_0_0_5)))) - 2 * to_field(h11_0_1_4))), u8_from_field_unsafe(to_field(h11_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_5) + 128 * (to_field(t7_0[5]) - 2 * to_field(h11_0_0_6)))) - 2 * to_field(h11_0_1_5))), u8_from_field_unsafe(to_field(h11_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_6) + 128 * (to_field(t7_0[6]) - 2 * to_field(h11_0_0_7)))) - 2 * to_field(h11_0_1_6))), u8_from_field_unsafe(to_field(h11_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_7) + 128 * (to_field(t7_0[7]) - 2 * to_field(h11_0_0_0)))) - 2 * to_field(h11_0_1_7))), u8_from_field_unsafe(to_field(h11_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_0) + 128 * (to_field(t7_0[0]) - 2 * to_field(h11_0_0_1)))) - 2 * to_field(h11_0_1_0)))];
+      -- b21_0 = rotl(t8, 55) = byte-rotl 7 + 1x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h21_0_0_0 = u8_shift_right(t8_0[1]);
+      let h21_0_0_1 = u8_shift_right(t8_0[2]);
+      let h21_0_0_2 = u8_shift_right(t8_0[3]);
+      let h21_0_0_3 = u8_shift_right(t8_0[4]);
+      let h21_0_0_4 = u8_shift_right(t8_0[5]);
+      let h21_0_0_5 = u8_shift_right(t8_0[6]);
+      let h21_0_0_6 = u8_shift_right(t8_0[7]);
+      let h21_0_0_7 = u8_shift_right(t8_0[0]);
+      let b21_0 = [u8_from_field_unsafe(to_field(h21_0_0_0) + 128 * (to_field(t8_0[2]) - 2 * to_field(h21_0_0_1))), u8_from_field_unsafe(to_field(h21_0_0_1) + 128 * (to_field(t8_0[3]) - 2 * to_field(h21_0_0_2))), u8_from_field_unsafe(to_field(h21_0_0_2) + 128 * (to_field(t8_0[4]) - 2 * to_field(h21_0_0_3))), u8_from_field_unsafe(to_field(h21_0_0_3) + 128 * (to_field(t8_0[5]) - 2 * to_field(h21_0_0_4))), u8_from_field_unsafe(to_field(h21_0_0_4) + 128 * (to_field(t8_0[6]) - 2 * to_field(h21_0_0_5))), u8_from_field_unsafe(to_field(h21_0_0_5) + 128 * (to_field(t8_0[7]) - 2 * to_field(h21_0_0_6))), u8_from_field_unsafe(to_field(h21_0_0_6) + 128 * (to_field(t8_0[0]) - 2 * to_field(h21_0_0_7))), u8_from_field_unsafe(to_field(h21_0_0_7) + 128 * (to_field(t8_0[1]) - 2 * to_field(h21_0_0_0)))];
+      -- b6_0 = rotl(t9, 20) = byte-rotl 2 + bit-shl 4 (decomposition)
+      let d6_0_0 = u8_bit_decomposition(t9_0[0]);
+      let d6_0_1 = u8_bit_decomposition(t9_0[1]);
+      let d6_0_2 = u8_bit_decomposition(t9_0[2]);
+      let d6_0_3 = u8_bit_decomposition(t9_0[3]);
+      let d6_0_4 = u8_bit_decomposition(t9_0[4]);
+      let d6_0_5 = u8_bit_decomposition(t9_0[5]);
+      let d6_0_6 = u8_bit_decomposition(t9_0[6]);
+      let d6_0_7 = u8_bit_decomposition(t9_0[7]);
+      let b6_0 = [u8_from_field_unsafe(d6_0_5[4] + 2 * d6_0_5[5] + 4 * d6_0_5[6] + 8 * d6_0_5[7] + 16 * d6_0_6[0] + 32 * d6_0_6[1] + 64 * d6_0_6[2] + 128 * d6_0_6[3]), u8_from_field_unsafe(d6_0_6[4] + 2 * d6_0_6[5] + 4 * d6_0_6[6] + 8 * d6_0_6[7] + 16 * d6_0_7[0] + 32 * d6_0_7[1] + 64 * d6_0_7[2] + 128 * d6_0_7[3]), u8_from_field_unsafe(d6_0_7[4] + 2 * d6_0_7[5] + 4 * d6_0_7[6] + 8 * d6_0_7[7] + 16 * d6_0_0[0] + 32 * d6_0_0[1] + 64 * d6_0_0[2] + 128 * d6_0_0[3]), u8_from_field_unsafe(d6_0_0[4] + 2 * d6_0_0[5] + 4 * d6_0_0[6] + 8 * d6_0_0[7] + 16 * d6_0_1[0] + 32 * d6_0_1[1] + 64 * d6_0_1[2] + 128 * d6_0_1[3]), u8_from_field_unsafe(d6_0_1[4] + 2 * d6_0_1[5] + 4 * d6_0_1[6] + 8 * d6_0_1[7] + 16 * d6_0_2[0] + 32 * d6_0_2[1] + 64 * d6_0_2[2] + 128 * d6_0_2[3]), u8_from_field_unsafe(d6_0_2[4] + 2 * d6_0_2[5] + 4 * d6_0_2[6] + 8 * d6_0_2[7] + 16 * d6_0_3[0] + 32 * d6_0_3[1] + 64 * d6_0_3[2] + 128 * d6_0_3[3]), u8_from_field_unsafe(d6_0_3[4] + 2 * d6_0_3[5] + 4 * d6_0_3[6] + 8 * d6_0_3[7] + 16 * d6_0_4[0] + 32 * d6_0_4[1] + 64 * d6_0_4[2] + 128 * d6_0_4[3]), u8_from_field_unsafe(d6_0_4[4] + 2 * d6_0_4[5] + 4 * d6_0_4[6] + 8 * d6_0_4[7] + 16 * d6_0_5[0] + 32 * d6_0_5[1] + 64 * d6_0_5[2] + 128 * d6_0_5[3])];
+      -- b7_0 = rotl(t10, 3) = byte-rotl 0 + 3x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a7_0_0_0, c7_0_0_0) = u8_add(t10_0[0], t10_0[0]);
+      let (a7_0_0_1, c7_0_0_1) = u8_add(t10_0[1], t10_0[1]);
+      let (a7_0_0_2, c7_0_0_2) = u8_add(t10_0[2], t10_0[2]);
+      let (a7_0_0_3, c7_0_0_3) = u8_add(t10_0[3], t10_0[3]);
+      let (a7_0_0_4, c7_0_0_4) = u8_add(t10_0[4], t10_0[4]);
+      let (a7_0_0_5, c7_0_0_5) = u8_add(t10_0[5], t10_0[5]);
+      let (a7_0_0_6, c7_0_0_6) = u8_add(t10_0[6], t10_0[6]);
+      let (a7_0_0_7, c7_0_0_7) = u8_add(t10_0[7], t10_0[7]);
+      let (a7_0_1_0, c7_0_1_0) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_0) + to_field(c7_0_0_7)), u8_from_field_unsafe(to_field(a7_0_0_0) + to_field(c7_0_0_7)));
+      let (a7_0_1_1, c7_0_1_1) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_1) + to_field(c7_0_0_0)), u8_from_field_unsafe(to_field(a7_0_0_1) + to_field(c7_0_0_0)));
+      let (a7_0_1_2, c7_0_1_2) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_2) + to_field(c7_0_0_1)), u8_from_field_unsafe(to_field(a7_0_0_2) + to_field(c7_0_0_1)));
+      let (a7_0_1_3, c7_0_1_3) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_3) + to_field(c7_0_0_2)), u8_from_field_unsafe(to_field(a7_0_0_3) + to_field(c7_0_0_2)));
+      let (a7_0_1_4, c7_0_1_4) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_4) + to_field(c7_0_0_3)), u8_from_field_unsafe(to_field(a7_0_0_4) + to_field(c7_0_0_3)));
+      let (a7_0_1_5, c7_0_1_5) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_5) + to_field(c7_0_0_4)), u8_from_field_unsafe(to_field(a7_0_0_5) + to_field(c7_0_0_4)));
+      let (a7_0_1_6, c7_0_1_6) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_6) + to_field(c7_0_0_5)), u8_from_field_unsafe(to_field(a7_0_0_6) + to_field(c7_0_0_5)));
+      let (a7_0_1_7, c7_0_1_7) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_7) + to_field(c7_0_0_6)), u8_from_field_unsafe(to_field(a7_0_0_7) + to_field(c7_0_0_6)));
+      let (a7_0_2_0, c7_0_2_0) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_0) + to_field(c7_0_1_7)), u8_from_field_unsafe(to_field(a7_0_1_0) + to_field(c7_0_1_7)));
+      let (a7_0_2_1, c7_0_2_1) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_1) + to_field(c7_0_1_0)), u8_from_field_unsafe(to_field(a7_0_1_1) + to_field(c7_0_1_0)));
+      let (a7_0_2_2, c7_0_2_2) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_2) + to_field(c7_0_1_1)), u8_from_field_unsafe(to_field(a7_0_1_2) + to_field(c7_0_1_1)));
+      let (a7_0_2_3, c7_0_2_3) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_3) + to_field(c7_0_1_2)), u8_from_field_unsafe(to_field(a7_0_1_3) + to_field(c7_0_1_2)));
+      let (a7_0_2_4, c7_0_2_4) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_4) + to_field(c7_0_1_3)), u8_from_field_unsafe(to_field(a7_0_1_4) + to_field(c7_0_1_3)));
+      let (a7_0_2_5, c7_0_2_5) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_5) + to_field(c7_0_1_4)), u8_from_field_unsafe(to_field(a7_0_1_5) + to_field(c7_0_1_4)));
+      let (a7_0_2_6, c7_0_2_6) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_6) + to_field(c7_0_1_5)), u8_from_field_unsafe(to_field(a7_0_1_6) + to_field(c7_0_1_5)));
+      let (a7_0_2_7, c7_0_2_7) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_7) + to_field(c7_0_1_6)), u8_from_field_unsafe(to_field(a7_0_1_7) + to_field(c7_0_1_6)));
+      let b7_0 = [u8_from_field_unsafe(to_field(a7_0_2_0) + to_field(c7_0_2_7)), u8_from_field_unsafe(to_field(a7_0_2_1) + to_field(c7_0_2_0)), u8_from_field_unsafe(to_field(a7_0_2_2) + to_field(c7_0_2_1)), u8_from_field_unsafe(to_field(a7_0_2_3) + to_field(c7_0_2_2)), u8_from_field_unsafe(to_field(a7_0_2_4) + to_field(c7_0_2_3)), u8_from_field_unsafe(to_field(a7_0_2_5) + to_field(c7_0_2_4)), u8_from_field_unsafe(to_field(a7_0_2_6) + to_field(c7_0_2_5)), u8_from_field_unsafe(to_field(a7_0_2_7) + to_field(c7_0_2_6))];
+      -- b17_0 = rotl(t11, 10) = byte-rotl 1 + 2x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a17_0_0_0, c17_0_0_0) = u8_add(t11_0[7], t11_0[7]);
+      let (a17_0_0_1, c17_0_0_1) = u8_add(t11_0[0], t11_0[0]);
+      let (a17_0_0_2, c17_0_0_2) = u8_add(t11_0[1], t11_0[1]);
+      let (a17_0_0_3, c17_0_0_3) = u8_add(t11_0[2], t11_0[2]);
+      let (a17_0_0_4, c17_0_0_4) = u8_add(t11_0[3], t11_0[3]);
+      let (a17_0_0_5, c17_0_0_5) = u8_add(t11_0[4], t11_0[4]);
+      let (a17_0_0_6, c17_0_0_6) = u8_add(t11_0[5], t11_0[5]);
+      let (a17_0_0_7, c17_0_0_7) = u8_add(t11_0[6], t11_0[6]);
+      let (a17_0_1_0, c17_0_1_0) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_0) + to_field(c17_0_0_7)), u8_from_field_unsafe(to_field(a17_0_0_0) + to_field(c17_0_0_7)));
+      let (a17_0_1_1, c17_0_1_1) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_1) + to_field(c17_0_0_0)), u8_from_field_unsafe(to_field(a17_0_0_1) + to_field(c17_0_0_0)));
+      let (a17_0_1_2, c17_0_1_2) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_2) + to_field(c17_0_0_1)), u8_from_field_unsafe(to_field(a17_0_0_2) + to_field(c17_0_0_1)));
+      let (a17_0_1_3, c17_0_1_3) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_3) + to_field(c17_0_0_2)), u8_from_field_unsafe(to_field(a17_0_0_3) + to_field(c17_0_0_2)));
+      let (a17_0_1_4, c17_0_1_4) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_4) + to_field(c17_0_0_3)), u8_from_field_unsafe(to_field(a17_0_0_4) + to_field(c17_0_0_3)));
+      let (a17_0_1_5, c17_0_1_5) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_5) + to_field(c17_0_0_4)), u8_from_field_unsafe(to_field(a17_0_0_5) + to_field(c17_0_0_4)));
+      let (a17_0_1_6, c17_0_1_6) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_6) + to_field(c17_0_0_5)), u8_from_field_unsafe(to_field(a17_0_0_6) + to_field(c17_0_0_5)));
+      let (a17_0_1_7, c17_0_1_7) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_7) + to_field(c17_0_0_6)), u8_from_field_unsafe(to_field(a17_0_0_7) + to_field(c17_0_0_6)));
+      let b17_0 = [u8_from_field_unsafe(to_field(a17_0_1_0) + to_field(c17_0_1_7)), u8_from_field_unsafe(to_field(a17_0_1_1) + to_field(c17_0_1_0)), u8_from_field_unsafe(to_field(a17_0_1_2) + to_field(c17_0_1_1)), u8_from_field_unsafe(to_field(a17_0_1_3) + to_field(c17_0_1_2)), u8_from_field_unsafe(to_field(a17_0_1_4) + to_field(c17_0_1_3)), u8_from_field_unsafe(to_field(a17_0_1_5) + to_field(c17_0_1_4)), u8_from_field_unsafe(to_field(a17_0_1_6) + to_field(c17_0_1_5)), u8_from_field_unsafe(to_field(a17_0_1_7) + to_field(c17_0_1_6))];
+      -- b2_0 = rotl(t12, 43) = byte-rotl 5 + 3x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a2_0_0_0, c2_0_0_0) = u8_add(t12_0[3], t12_0[3]);
+      let (a2_0_0_1, c2_0_0_1) = u8_add(t12_0[4], t12_0[4]);
+      let (a2_0_0_2, c2_0_0_2) = u8_add(t12_0[5], t12_0[5]);
+      let (a2_0_0_3, c2_0_0_3) = u8_add(t12_0[6], t12_0[6]);
+      let (a2_0_0_4, c2_0_0_4) = u8_add(t12_0[7], t12_0[7]);
+      let (a2_0_0_5, c2_0_0_5) = u8_add(t12_0[0], t12_0[0]);
+      let (a2_0_0_6, c2_0_0_6) = u8_add(t12_0[1], t12_0[1]);
+      let (a2_0_0_7, c2_0_0_7) = u8_add(t12_0[2], t12_0[2]);
+      let (a2_0_1_0, c2_0_1_0) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_0) + to_field(c2_0_0_7)), u8_from_field_unsafe(to_field(a2_0_0_0) + to_field(c2_0_0_7)));
+      let (a2_0_1_1, c2_0_1_1) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_1) + to_field(c2_0_0_0)), u8_from_field_unsafe(to_field(a2_0_0_1) + to_field(c2_0_0_0)));
+      let (a2_0_1_2, c2_0_1_2) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_2) + to_field(c2_0_0_1)), u8_from_field_unsafe(to_field(a2_0_0_2) + to_field(c2_0_0_1)));
+      let (a2_0_1_3, c2_0_1_3) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_3) + to_field(c2_0_0_2)), u8_from_field_unsafe(to_field(a2_0_0_3) + to_field(c2_0_0_2)));
+      let (a2_0_1_4, c2_0_1_4) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_4) + to_field(c2_0_0_3)), u8_from_field_unsafe(to_field(a2_0_0_4) + to_field(c2_0_0_3)));
+      let (a2_0_1_5, c2_0_1_5) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_5) + to_field(c2_0_0_4)), u8_from_field_unsafe(to_field(a2_0_0_5) + to_field(c2_0_0_4)));
+      let (a2_0_1_6, c2_0_1_6) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_6) + to_field(c2_0_0_5)), u8_from_field_unsafe(to_field(a2_0_0_6) + to_field(c2_0_0_5)));
+      let (a2_0_1_7, c2_0_1_7) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_7) + to_field(c2_0_0_6)), u8_from_field_unsafe(to_field(a2_0_0_7) + to_field(c2_0_0_6)));
+      let (a2_0_2_0, c2_0_2_0) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_0) + to_field(c2_0_1_7)), u8_from_field_unsafe(to_field(a2_0_1_0) + to_field(c2_0_1_7)));
+      let (a2_0_2_1, c2_0_2_1) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_1) + to_field(c2_0_1_0)), u8_from_field_unsafe(to_field(a2_0_1_1) + to_field(c2_0_1_0)));
+      let (a2_0_2_2, c2_0_2_2) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_2) + to_field(c2_0_1_1)), u8_from_field_unsafe(to_field(a2_0_1_2) + to_field(c2_0_1_1)));
+      let (a2_0_2_3, c2_0_2_3) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_3) + to_field(c2_0_1_2)), u8_from_field_unsafe(to_field(a2_0_1_3) + to_field(c2_0_1_2)));
+      let (a2_0_2_4, c2_0_2_4) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_4) + to_field(c2_0_1_3)), u8_from_field_unsafe(to_field(a2_0_1_4) + to_field(c2_0_1_3)));
+      let (a2_0_2_5, c2_0_2_5) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_5) + to_field(c2_0_1_4)), u8_from_field_unsafe(to_field(a2_0_1_5) + to_field(c2_0_1_4)));
+      let (a2_0_2_6, c2_0_2_6) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_6) + to_field(c2_0_1_5)), u8_from_field_unsafe(to_field(a2_0_1_6) + to_field(c2_0_1_5)));
+      let (a2_0_2_7, c2_0_2_7) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_7) + to_field(c2_0_1_6)), u8_from_field_unsafe(to_field(a2_0_1_7) + to_field(c2_0_1_6)));
+      let b2_0 = [u8_from_field_unsafe(to_field(a2_0_2_0) + to_field(c2_0_2_7)), u8_from_field_unsafe(to_field(a2_0_2_1) + to_field(c2_0_2_0)), u8_from_field_unsafe(to_field(a2_0_2_2) + to_field(c2_0_2_1)), u8_from_field_unsafe(to_field(a2_0_2_3) + to_field(c2_0_2_2)), u8_from_field_unsafe(to_field(a2_0_2_4) + to_field(c2_0_2_3)), u8_from_field_unsafe(to_field(a2_0_2_5) + to_field(c2_0_2_4)), u8_from_field_unsafe(to_field(a2_0_2_6) + to_field(c2_0_2_5)), u8_from_field_unsafe(to_field(a2_0_2_7) + to_field(c2_0_2_6))];
+      -- b12_0 = rotl(t13, 25) = byte-rotl 3 + 1x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a12_0_0_0, c12_0_0_0) = u8_add(t13_0[5], t13_0[5]);
+      let (a12_0_0_1, c12_0_0_1) = u8_add(t13_0[6], t13_0[6]);
+      let (a12_0_0_2, c12_0_0_2) = u8_add(t13_0[7], t13_0[7]);
+      let (a12_0_0_3, c12_0_0_3) = u8_add(t13_0[0], t13_0[0]);
+      let (a12_0_0_4, c12_0_0_4) = u8_add(t13_0[1], t13_0[1]);
+      let (a12_0_0_5, c12_0_0_5) = u8_add(t13_0[2], t13_0[2]);
+      let (a12_0_0_6, c12_0_0_6) = u8_add(t13_0[3], t13_0[3]);
+      let (a12_0_0_7, c12_0_0_7) = u8_add(t13_0[4], t13_0[4]);
+      let b12_0 = [u8_from_field_unsafe(to_field(a12_0_0_0) + to_field(c12_0_0_7)), u8_from_field_unsafe(to_field(a12_0_0_1) + to_field(c12_0_0_0)), u8_from_field_unsafe(to_field(a12_0_0_2) + to_field(c12_0_0_1)), u8_from_field_unsafe(to_field(a12_0_0_3) + to_field(c12_0_0_2)), u8_from_field_unsafe(to_field(a12_0_0_4) + to_field(c12_0_0_3)), u8_from_field_unsafe(to_field(a12_0_0_5) + to_field(c12_0_0_4)), u8_from_field_unsafe(to_field(a12_0_0_6) + to_field(c12_0_0_5)), u8_from_field_unsafe(to_field(a12_0_0_7) + to_field(c12_0_0_6))];
+      -- b22_0 = rotl(t14, 39) = byte-rotl 5 + 1x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h22_0_0_0 = u8_shift_right(t14_0[3]);
+      let h22_0_0_1 = u8_shift_right(t14_0[4]);
+      let h22_0_0_2 = u8_shift_right(t14_0[5]);
+      let h22_0_0_3 = u8_shift_right(t14_0[6]);
+      let h22_0_0_4 = u8_shift_right(t14_0[7]);
+      let h22_0_0_5 = u8_shift_right(t14_0[0]);
+      let h22_0_0_6 = u8_shift_right(t14_0[1]);
+      let h22_0_0_7 = u8_shift_right(t14_0[2]);
+      let b22_0 = [u8_from_field_unsafe(to_field(h22_0_0_0) + 128 * (to_field(t14_0[4]) - 2 * to_field(h22_0_0_1))), u8_from_field_unsafe(to_field(h22_0_0_1) + 128 * (to_field(t14_0[5]) - 2 * to_field(h22_0_0_2))), u8_from_field_unsafe(to_field(h22_0_0_2) + 128 * (to_field(t14_0[6]) - 2 * to_field(h22_0_0_3))), u8_from_field_unsafe(to_field(h22_0_0_3) + 128 * (to_field(t14_0[7]) - 2 * to_field(h22_0_0_4))), u8_from_field_unsafe(to_field(h22_0_0_4) + 128 * (to_field(t14_0[0]) - 2 * to_field(h22_0_0_5))), u8_from_field_unsafe(to_field(h22_0_0_5) + 128 * (to_field(t14_0[1]) - 2 * to_field(h22_0_0_6))), u8_from_field_unsafe(to_field(h22_0_0_6) + 128 * (to_field(t14_0[2]) - 2 * to_field(h22_0_0_7))), u8_from_field_unsafe(to_field(h22_0_0_7) + 128 * (to_field(t14_0[3]) - 2 * to_field(h22_0_0_0)))];
+      -- b23_0 = rotl(t15, 41) = byte-rotl 5 + 1x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a23_0_0_0, c23_0_0_0) = u8_add(t15_0[3], t15_0[3]);
+      let (a23_0_0_1, c23_0_0_1) = u8_add(t15_0[4], t15_0[4]);
+      let (a23_0_0_2, c23_0_0_2) = u8_add(t15_0[5], t15_0[5]);
+      let (a23_0_0_3, c23_0_0_3) = u8_add(t15_0[6], t15_0[6]);
+      let (a23_0_0_4, c23_0_0_4) = u8_add(t15_0[7], t15_0[7]);
+      let (a23_0_0_5, c23_0_0_5) = u8_add(t15_0[0], t15_0[0]);
+      let (a23_0_0_6, c23_0_0_6) = u8_add(t15_0[1], t15_0[1]);
+      let (a23_0_0_7, c23_0_0_7) = u8_add(t15_0[2], t15_0[2]);
+      let b23_0 = [u8_from_field_unsafe(to_field(a23_0_0_0) + to_field(c23_0_0_7)), u8_from_field_unsafe(to_field(a23_0_0_1) + to_field(c23_0_0_0)), u8_from_field_unsafe(to_field(a23_0_0_2) + to_field(c23_0_0_1)), u8_from_field_unsafe(to_field(a23_0_0_3) + to_field(c23_0_0_2)), u8_from_field_unsafe(to_field(a23_0_0_4) + to_field(c23_0_0_3)), u8_from_field_unsafe(to_field(a23_0_0_5) + to_field(c23_0_0_4)), u8_from_field_unsafe(to_field(a23_0_0_6) + to_field(c23_0_0_5)), u8_from_field_unsafe(to_field(a23_0_0_7) + to_field(c23_0_0_6))];
+      -- b8_0 = rotl(t16, 45) = byte-rotl 6 + 3x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h8_0_0_0 = u8_shift_right(t16_0[2]);
+      let h8_0_0_1 = u8_shift_right(t16_0[3]);
+      let h8_0_0_2 = u8_shift_right(t16_0[4]);
+      let h8_0_0_3 = u8_shift_right(t16_0[5]);
+      let h8_0_0_4 = u8_shift_right(t16_0[6]);
+      let h8_0_0_5 = u8_shift_right(t16_0[7]);
+      let h8_0_0_6 = u8_shift_right(t16_0[0]);
+      let h8_0_0_7 = u8_shift_right(t16_0[1]);
+      let h8_0_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_0) + 128 * (to_field(t16_0[3]) - 2 * to_field(h8_0_0_1))));
+      let h8_0_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_1) + 128 * (to_field(t16_0[4]) - 2 * to_field(h8_0_0_2))));
+      let h8_0_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_2) + 128 * (to_field(t16_0[5]) - 2 * to_field(h8_0_0_3))));
+      let h8_0_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_3) + 128 * (to_field(t16_0[6]) - 2 * to_field(h8_0_0_4))));
+      let h8_0_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_4) + 128 * (to_field(t16_0[7]) - 2 * to_field(h8_0_0_5))));
+      let h8_0_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_5) + 128 * (to_field(t16_0[0]) - 2 * to_field(h8_0_0_6))));
+      let h8_0_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_6) + 128 * (to_field(t16_0[1]) - 2 * to_field(h8_0_0_7))));
+      let h8_0_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_7) + 128 * (to_field(t16_0[2]) - 2 * to_field(h8_0_0_0))));
+      let h8_0_2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_1) + 128 * (to_field(t16_0[4]) - 2 * to_field(h8_0_0_2)))) - 2 * to_field(h8_0_1_1))));
+      let h8_0_2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_2) + 128 * (to_field(t16_0[5]) - 2 * to_field(h8_0_0_3)))) - 2 * to_field(h8_0_1_2))));
+      let h8_0_2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_3) + 128 * (to_field(t16_0[6]) - 2 * to_field(h8_0_0_4)))) - 2 * to_field(h8_0_1_3))));
+      let h8_0_2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_4) + 128 * (to_field(t16_0[7]) - 2 * to_field(h8_0_0_5)))) - 2 * to_field(h8_0_1_4))));
+      let h8_0_2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_5) + 128 * (to_field(t16_0[0]) - 2 * to_field(h8_0_0_6)))) - 2 * to_field(h8_0_1_5))));
+      let h8_0_2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_6) + 128 * (to_field(t16_0[1]) - 2 * to_field(h8_0_0_7)))) - 2 * to_field(h8_0_1_6))));
+      let h8_0_2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_7) + 128 * (to_field(t16_0[2]) - 2 * to_field(h8_0_0_0)))) - 2 * to_field(h8_0_1_7))));
+      let h8_0_2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_0) + 128 * (to_field(t16_0[3]) - 2 * to_field(h8_0_0_1)))) - 2 * to_field(h8_0_1_0))));
+      let b8_0 = [u8_from_field_unsafe(to_field(h8_0_2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_2) + 128 * (to_field(t16_0[5]) - 2 * to_field(h8_0_0_3)))) - 2 * to_field(h8_0_1_2)))) - 2 * to_field(h8_0_2_1))), u8_from_field_unsafe(to_field(h8_0_2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_3) + 128 * (to_field(t16_0[6]) - 2 * to_field(h8_0_0_4)))) - 2 * to_field(h8_0_1_3)))) - 2 * to_field(h8_0_2_2))), u8_from_field_unsafe(to_field(h8_0_2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_4) + 128 * (to_field(t16_0[7]) - 2 * to_field(h8_0_0_5)))) - 2 * to_field(h8_0_1_4)))) - 2 * to_field(h8_0_2_3))), u8_from_field_unsafe(to_field(h8_0_2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_5) + 128 * (to_field(t16_0[0]) - 2 * to_field(h8_0_0_6)))) - 2 * to_field(h8_0_1_5)))) - 2 * to_field(h8_0_2_4))), u8_from_field_unsafe(to_field(h8_0_2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_6) + 128 * (to_field(t16_0[1]) - 2 * to_field(h8_0_0_7)))) - 2 * to_field(h8_0_1_6)))) - 2 * to_field(h8_0_2_5))), u8_from_field_unsafe(to_field(h8_0_2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_7) + 128 * (to_field(t16_0[2]) - 2 * to_field(h8_0_0_0)))) - 2 * to_field(h8_0_1_7)))) - 2 * to_field(h8_0_2_6))), u8_from_field_unsafe(to_field(h8_0_2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_0) + 128 * (to_field(t16_0[3]) - 2 * to_field(h8_0_0_1)))) - 2 * to_field(h8_0_1_0)))) - 2 * to_field(h8_0_2_7))), u8_from_field_unsafe(to_field(h8_0_2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_1) + 128 * (to_field(t16_0[4]) - 2 * to_field(h8_0_0_2)))) - 2 * to_field(h8_0_1_1)))) - 2 * to_field(h8_0_2_0)))];
+      -- b18_0 = rotl(t17, 15) = byte-rotl 2 + 1x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h18_0_0_0 = u8_shift_right(t17_0[6]);
+      let h18_0_0_1 = u8_shift_right(t17_0[7]);
+      let h18_0_0_2 = u8_shift_right(t17_0[0]);
+      let h18_0_0_3 = u8_shift_right(t17_0[1]);
+      let h18_0_0_4 = u8_shift_right(t17_0[2]);
+      let h18_0_0_5 = u8_shift_right(t17_0[3]);
+      let h18_0_0_6 = u8_shift_right(t17_0[4]);
+      let h18_0_0_7 = u8_shift_right(t17_0[5]);
+      let b18_0 = [u8_from_field_unsafe(to_field(h18_0_0_0) + 128 * (to_field(t17_0[7]) - 2 * to_field(h18_0_0_1))), u8_from_field_unsafe(to_field(h18_0_0_1) + 128 * (to_field(t17_0[0]) - 2 * to_field(h18_0_0_2))), u8_from_field_unsafe(to_field(h18_0_0_2) + 128 * (to_field(t17_0[1]) - 2 * to_field(h18_0_0_3))), u8_from_field_unsafe(to_field(h18_0_0_3) + 128 * (to_field(t17_0[2]) - 2 * to_field(h18_0_0_4))), u8_from_field_unsafe(to_field(h18_0_0_4) + 128 * (to_field(t17_0[3]) - 2 * to_field(h18_0_0_5))), u8_from_field_unsafe(to_field(h18_0_0_5) + 128 * (to_field(t17_0[4]) - 2 * to_field(h18_0_0_6))), u8_from_field_unsafe(to_field(h18_0_0_6) + 128 * (to_field(t17_0[5]) - 2 * to_field(h18_0_0_7))), u8_from_field_unsafe(to_field(h18_0_0_7) + 128 * (to_field(t17_0[6]) - 2 * to_field(h18_0_0_0)))];
+      -- b3_0 = rotl(t18, 21) = byte-rotl 3 + 3x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h3_0_0_0 = u8_shift_right(t18_0[5]);
+      let h3_0_0_1 = u8_shift_right(t18_0[6]);
+      let h3_0_0_2 = u8_shift_right(t18_0[7]);
+      let h3_0_0_3 = u8_shift_right(t18_0[0]);
+      let h3_0_0_4 = u8_shift_right(t18_0[1]);
+      let h3_0_0_5 = u8_shift_right(t18_0[2]);
+      let h3_0_0_6 = u8_shift_right(t18_0[3]);
+      let h3_0_0_7 = u8_shift_right(t18_0[4]);
+      let h3_0_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_0) + 128 * (to_field(t18_0[6]) - 2 * to_field(h3_0_0_1))));
+      let h3_0_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_1) + 128 * (to_field(t18_0[7]) - 2 * to_field(h3_0_0_2))));
+      let h3_0_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_2) + 128 * (to_field(t18_0[0]) - 2 * to_field(h3_0_0_3))));
+      let h3_0_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_3) + 128 * (to_field(t18_0[1]) - 2 * to_field(h3_0_0_4))));
+      let h3_0_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_4) + 128 * (to_field(t18_0[2]) - 2 * to_field(h3_0_0_5))));
+      let h3_0_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_5) + 128 * (to_field(t18_0[3]) - 2 * to_field(h3_0_0_6))));
+      let h3_0_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_6) + 128 * (to_field(t18_0[4]) - 2 * to_field(h3_0_0_7))));
+      let h3_0_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_7) + 128 * (to_field(t18_0[5]) - 2 * to_field(h3_0_0_0))));
+      let h3_0_2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_1) + 128 * (to_field(t18_0[7]) - 2 * to_field(h3_0_0_2)))) - 2 * to_field(h3_0_1_1))));
+      let h3_0_2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_2) + 128 * (to_field(t18_0[0]) - 2 * to_field(h3_0_0_3)))) - 2 * to_field(h3_0_1_2))));
+      let h3_0_2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_3) + 128 * (to_field(t18_0[1]) - 2 * to_field(h3_0_0_4)))) - 2 * to_field(h3_0_1_3))));
+      let h3_0_2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_4) + 128 * (to_field(t18_0[2]) - 2 * to_field(h3_0_0_5)))) - 2 * to_field(h3_0_1_4))));
+      let h3_0_2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_5) + 128 * (to_field(t18_0[3]) - 2 * to_field(h3_0_0_6)))) - 2 * to_field(h3_0_1_5))));
+      let h3_0_2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_6) + 128 * (to_field(t18_0[4]) - 2 * to_field(h3_0_0_7)))) - 2 * to_field(h3_0_1_6))));
+      let h3_0_2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_7) + 128 * (to_field(t18_0[5]) - 2 * to_field(h3_0_0_0)))) - 2 * to_field(h3_0_1_7))));
+      let h3_0_2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_0) + 128 * (to_field(t18_0[6]) - 2 * to_field(h3_0_0_1)))) - 2 * to_field(h3_0_1_0))));
+      let b3_0 = [u8_from_field_unsafe(to_field(h3_0_2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_2) + 128 * (to_field(t18_0[0]) - 2 * to_field(h3_0_0_3)))) - 2 * to_field(h3_0_1_2)))) - 2 * to_field(h3_0_2_1))), u8_from_field_unsafe(to_field(h3_0_2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_3) + 128 * (to_field(t18_0[1]) - 2 * to_field(h3_0_0_4)))) - 2 * to_field(h3_0_1_3)))) - 2 * to_field(h3_0_2_2))), u8_from_field_unsafe(to_field(h3_0_2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_4) + 128 * (to_field(t18_0[2]) - 2 * to_field(h3_0_0_5)))) - 2 * to_field(h3_0_1_4)))) - 2 * to_field(h3_0_2_3))), u8_from_field_unsafe(to_field(h3_0_2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_5) + 128 * (to_field(t18_0[3]) - 2 * to_field(h3_0_0_6)))) - 2 * to_field(h3_0_1_5)))) - 2 * to_field(h3_0_2_4))), u8_from_field_unsafe(to_field(h3_0_2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_6) + 128 * (to_field(t18_0[4]) - 2 * to_field(h3_0_0_7)))) - 2 * to_field(h3_0_1_6)))) - 2 * to_field(h3_0_2_5))), u8_from_field_unsafe(to_field(h3_0_2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_7) + 128 * (to_field(t18_0[5]) - 2 * to_field(h3_0_0_0)))) - 2 * to_field(h3_0_1_7)))) - 2 * to_field(h3_0_2_6))), u8_from_field_unsafe(to_field(h3_0_2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_0) + 128 * (to_field(t18_0[6]) - 2 * to_field(h3_0_0_1)))) - 2 * to_field(h3_0_1_0)))) - 2 * to_field(h3_0_2_7))), u8_from_field_unsafe(to_field(h3_0_2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_1) + 128 * (to_field(t18_0[7]) - 2 * to_field(h3_0_0_2)))) - 2 * to_field(h3_0_1_1)))) - 2 * to_field(h3_0_2_0)))];
+      -- b13_0 = rotl(t19, 8): byte rotation only (free)
+      let b13_0 = [t19_0[7], t19_0[0], t19_0[1], t19_0[2], t19_0[3], t19_0[4], t19_0[5], t19_0[6]];
+      -- b14_0 = rotl(t20, 18) = byte-rotl 2 + 2x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a14_0_0_0, c14_0_0_0) = u8_add(t20_0[6], t20_0[6]);
+      let (a14_0_0_1, c14_0_0_1) = u8_add(t20_0[7], t20_0[7]);
+      let (a14_0_0_2, c14_0_0_2) = u8_add(t20_0[0], t20_0[0]);
+      let (a14_0_0_3, c14_0_0_3) = u8_add(t20_0[1], t20_0[1]);
+      let (a14_0_0_4, c14_0_0_4) = u8_add(t20_0[2], t20_0[2]);
+      let (a14_0_0_5, c14_0_0_5) = u8_add(t20_0[3], t20_0[3]);
+      let (a14_0_0_6, c14_0_0_6) = u8_add(t20_0[4], t20_0[4]);
+      let (a14_0_0_7, c14_0_0_7) = u8_add(t20_0[5], t20_0[5]);
+      let (a14_0_1_0, c14_0_1_0) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_0) + to_field(c14_0_0_7)), u8_from_field_unsafe(to_field(a14_0_0_0) + to_field(c14_0_0_7)));
+      let (a14_0_1_1, c14_0_1_1) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_1) + to_field(c14_0_0_0)), u8_from_field_unsafe(to_field(a14_0_0_1) + to_field(c14_0_0_0)));
+      let (a14_0_1_2, c14_0_1_2) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_2) + to_field(c14_0_0_1)), u8_from_field_unsafe(to_field(a14_0_0_2) + to_field(c14_0_0_1)));
+      let (a14_0_1_3, c14_0_1_3) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_3) + to_field(c14_0_0_2)), u8_from_field_unsafe(to_field(a14_0_0_3) + to_field(c14_0_0_2)));
+      let (a14_0_1_4, c14_0_1_4) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_4) + to_field(c14_0_0_3)), u8_from_field_unsafe(to_field(a14_0_0_4) + to_field(c14_0_0_3)));
+      let (a14_0_1_5, c14_0_1_5) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_5) + to_field(c14_0_0_4)), u8_from_field_unsafe(to_field(a14_0_0_5) + to_field(c14_0_0_4)));
+      let (a14_0_1_6, c14_0_1_6) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_6) + to_field(c14_0_0_5)), u8_from_field_unsafe(to_field(a14_0_0_6) + to_field(c14_0_0_5)));
+      let (a14_0_1_7, c14_0_1_7) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_7) + to_field(c14_0_0_6)), u8_from_field_unsafe(to_field(a14_0_0_7) + to_field(c14_0_0_6)));
+      let b14_0 = [u8_from_field_unsafe(to_field(a14_0_1_0) + to_field(c14_0_1_7)), u8_from_field_unsafe(to_field(a14_0_1_1) + to_field(c14_0_1_0)), u8_from_field_unsafe(to_field(a14_0_1_2) + to_field(c14_0_1_1)), u8_from_field_unsafe(to_field(a14_0_1_3) + to_field(c14_0_1_2)), u8_from_field_unsafe(to_field(a14_0_1_4) + to_field(c14_0_1_3)), u8_from_field_unsafe(to_field(a14_0_1_5) + to_field(c14_0_1_4)), u8_from_field_unsafe(to_field(a14_0_1_6) + to_field(c14_0_1_5)), u8_from_field_unsafe(to_field(a14_0_1_7) + to_field(c14_0_1_6))];
+      -- b24_0 = rotl(t21, 2) = byte-rotl 0 + 2x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
+      let (a24_0_0_0, c24_0_0_0) = u8_add(t21_0[0], t21_0[0]);
+      let (a24_0_0_1, c24_0_0_1) = u8_add(t21_0[1], t21_0[1]);
+      let (a24_0_0_2, c24_0_0_2) = u8_add(t21_0[2], t21_0[2]);
+      let (a24_0_0_3, c24_0_0_3) = u8_add(t21_0[3], t21_0[3]);
+      let (a24_0_0_4, c24_0_0_4) = u8_add(t21_0[4], t21_0[4]);
+      let (a24_0_0_5, c24_0_0_5) = u8_add(t21_0[5], t21_0[5]);
+      let (a24_0_0_6, c24_0_0_6) = u8_add(t21_0[6], t21_0[6]);
+      let (a24_0_0_7, c24_0_0_7) = u8_add(t21_0[7], t21_0[7]);
+      let (a24_0_1_0, c24_0_1_0) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_0) + to_field(c24_0_0_7)), u8_from_field_unsafe(to_field(a24_0_0_0) + to_field(c24_0_0_7)));
+      let (a24_0_1_1, c24_0_1_1) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_1) + to_field(c24_0_0_0)), u8_from_field_unsafe(to_field(a24_0_0_1) + to_field(c24_0_0_0)));
+      let (a24_0_1_2, c24_0_1_2) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_2) + to_field(c24_0_0_1)), u8_from_field_unsafe(to_field(a24_0_0_2) + to_field(c24_0_0_1)));
+      let (a24_0_1_3, c24_0_1_3) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_3) + to_field(c24_0_0_2)), u8_from_field_unsafe(to_field(a24_0_0_3) + to_field(c24_0_0_2)));
+      let (a24_0_1_4, c24_0_1_4) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_4) + to_field(c24_0_0_3)), u8_from_field_unsafe(to_field(a24_0_0_4) + to_field(c24_0_0_3)));
+      let (a24_0_1_5, c24_0_1_5) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_5) + to_field(c24_0_0_4)), u8_from_field_unsafe(to_field(a24_0_0_5) + to_field(c24_0_0_4)));
+      let (a24_0_1_6, c24_0_1_6) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_6) + to_field(c24_0_0_5)), u8_from_field_unsafe(to_field(a24_0_0_6) + to_field(c24_0_0_5)));
+      let (a24_0_1_7, c24_0_1_7) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_7) + to_field(c24_0_0_6)), u8_from_field_unsafe(to_field(a24_0_0_7) + to_field(c24_0_0_6)));
+      let b24_0 = [u8_from_field_unsafe(to_field(a24_0_1_0) + to_field(c24_0_1_7)), u8_from_field_unsafe(to_field(a24_0_1_1) + to_field(c24_0_1_0)), u8_from_field_unsafe(to_field(a24_0_1_2) + to_field(c24_0_1_1)), u8_from_field_unsafe(to_field(a24_0_1_3) + to_field(c24_0_1_2)), u8_from_field_unsafe(to_field(a24_0_1_4) + to_field(c24_0_1_3)), u8_from_field_unsafe(to_field(a24_0_1_5) + to_field(c24_0_1_4)), u8_from_field_unsafe(to_field(a24_0_1_6) + to_field(c24_0_1_5)), u8_from_field_unsafe(to_field(a24_0_1_7) + to_field(c24_0_1_6))];
+      -- b9_0 = rotl(t22, 61) = byte-rotl 8 + 3x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h9_0_0_0 = u8_shift_right(t22_0[0]);
+      let h9_0_0_1 = u8_shift_right(t22_0[1]);
+      let h9_0_0_2 = u8_shift_right(t22_0[2]);
+      let h9_0_0_3 = u8_shift_right(t22_0[3]);
+      let h9_0_0_4 = u8_shift_right(t22_0[4]);
+      let h9_0_0_5 = u8_shift_right(t22_0[5]);
+      let h9_0_0_6 = u8_shift_right(t22_0[6]);
+      let h9_0_0_7 = u8_shift_right(t22_0[7]);
+      let h9_0_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_0) + 128 * (to_field(t22_0[1]) - 2 * to_field(h9_0_0_1))));
+      let h9_0_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_1) + 128 * (to_field(t22_0[2]) - 2 * to_field(h9_0_0_2))));
+      let h9_0_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_2) + 128 * (to_field(t22_0[3]) - 2 * to_field(h9_0_0_3))));
+      let h9_0_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_3) + 128 * (to_field(t22_0[4]) - 2 * to_field(h9_0_0_4))));
+      let h9_0_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_4) + 128 * (to_field(t22_0[5]) - 2 * to_field(h9_0_0_5))));
+      let h9_0_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_5) + 128 * (to_field(t22_0[6]) - 2 * to_field(h9_0_0_6))));
+      let h9_0_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_6) + 128 * (to_field(t22_0[7]) - 2 * to_field(h9_0_0_7))));
+      let h9_0_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_7) + 128 * (to_field(t22_0[0]) - 2 * to_field(h9_0_0_0))));
+      let h9_0_2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_1) + 128 * (to_field(t22_0[2]) - 2 * to_field(h9_0_0_2)))) - 2 * to_field(h9_0_1_1))));
+      let h9_0_2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_2) + 128 * (to_field(t22_0[3]) - 2 * to_field(h9_0_0_3)))) - 2 * to_field(h9_0_1_2))));
+      let h9_0_2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_3) + 128 * (to_field(t22_0[4]) - 2 * to_field(h9_0_0_4)))) - 2 * to_field(h9_0_1_3))));
+      let h9_0_2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_4) + 128 * (to_field(t22_0[5]) - 2 * to_field(h9_0_0_5)))) - 2 * to_field(h9_0_1_4))));
+      let h9_0_2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_5) + 128 * (to_field(t22_0[6]) - 2 * to_field(h9_0_0_6)))) - 2 * to_field(h9_0_1_5))));
+      let h9_0_2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_6) + 128 * (to_field(t22_0[7]) - 2 * to_field(h9_0_0_7)))) - 2 * to_field(h9_0_1_6))));
+      let h9_0_2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_7) + 128 * (to_field(t22_0[0]) - 2 * to_field(h9_0_0_0)))) - 2 * to_field(h9_0_1_7))));
+      let h9_0_2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_0) + 128 * (to_field(t22_0[1]) - 2 * to_field(h9_0_0_1)))) - 2 * to_field(h9_0_1_0))));
+      let b9_0 = [u8_from_field_unsafe(to_field(h9_0_2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_2) + 128 * (to_field(t22_0[3]) - 2 * to_field(h9_0_0_3)))) - 2 * to_field(h9_0_1_2)))) - 2 * to_field(h9_0_2_1))), u8_from_field_unsafe(to_field(h9_0_2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_3) + 128 * (to_field(t22_0[4]) - 2 * to_field(h9_0_0_4)))) - 2 * to_field(h9_0_1_3)))) - 2 * to_field(h9_0_2_2))), u8_from_field_unsafe(to_field(h9_0_2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_4) + 128 * (to_field(t22_0[5]) - 2 * to_field(h9_0_0_5)))) - 2 * to_field(h9_0_1_4)))) - 2 * to_field(h9_0_2_3))), u8_from_field_unsafe(to_field(h9_0_2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_5) + 128 * (to_field(t22_0[6]) - 2 * to_field(h9_0_0_6)))) - 2 * to_field(h9_0_1_5)))) - 2 * to_field(h9_0_2_4))), u8_from_field_unsafe(to_field(h9_0_2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_6) + 128 * (to_field(t22_0[7]) - 2 * to_field(h9_0_0_7)))) - 2 * to_field(h9_0_1_6)))) - 2 * to_field(h9_0_2_5))), u8_from_field_unsafe(to_field(h9_0_2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_7) + 128 * (to_field(t22_0[0]) - 2 * to_field(h9_0_0_0)))) - 2 * to_field(h9_0_1_7)))) - 2 * to_field(h9_0_2_6))), u8_from_field_unsafe(to_field(h9_0_2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_0) + 128 * (to_field(t22_0[1]) - 2 * to_field(h9_0_0_1)))) - 2 * to_field(h9_0_1_0)))) - 2 * to_field(h9_0_2_7))), u8_from_field_unsafe(to_field(h9_0_2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_1) + 128 * (to_field(t22_0[2]) - 2 * to_field(h9_0_0_2)))) - 2 * to_field(h9_0_1_1)))) - 2 * to_field(h9_0_2_0)))];
+      -- b19_0 = rotl(t23, 56): byte rotation only (free)
+      let b19_0 = [t23_0[1], t23_0[2], t23_0[3], t23_0[4], t23_0[5], t23_0[6], t23_0[7], t23_0[0]];
+      -- b4_0 = rotl(t24, 14) = byte-rotl 2 + 2x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
+      let h4_0_0_0 = u8_shift_right(t24_0[6]);
+      let h4_0_0_1 = u8_shift_right(t24_0[7]);
+      let h4_0_0_2 = u8_shift_right(t24_0[0]);
+      let h4_0_0_3 = u8_shift_right(t24_0[1]);
+      let h4_0_0_4 = u8_shift_right(t24_0[2]);
+      let h4_0_0_5 = u8_shift_right(t24_0[3]);
+      let h4_0_0_6 = u8_shift_right(t24_0[4]);
+      let h4_0_0_7 = u8_shift_right(t24_0[5]);
+      let h4_0_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_0) + 128 * (to_field(t24_0[7]) - 2 * to_field(h4_0_0_1))));
+      let h4_0_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_1) + 128 * (to_field(t24_0[0]) - 2 * to_field(h4_0_0_2))));
+      let h4_0_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_2) + 128 * (to_field(t24_0[1]) - 2 * to_field(h4_0_0_3))));
+      let h4_0_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_3) + 128 * (to_field(t24_0[2]) - 2 * to_field(h4_0_0_4))));
+      let h4_0_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_4) + 128 * (to_field(t24_0[3]) - 2 * to_field(h4_0_0_5))));
+      let h4_0_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_5) + 128 * (to_field(t24_0[4]) - 2 * to_field(h4_0_0_6))));
+      let h4_0_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_6) + 128 * (to_field(t24_0[5]) - 2 * to_field(h4_0_0_7))));
+      let h4_0_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_7) + 128 * (to_field(t24_0[6]) - 2 * to_field(h4_0_0_0))));
+      let b4_0 = [u8_from_field_unsafe(to_field(h4_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_1) + 128 * (to_field(t24_0[0]) - 2 * to_field(h4_0_0_2)))) - 2 * to_field(h4_0_1_1))), u8_from_field_unsafe(to_field(h4_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_2) + 128 * (to_field(t24_0[1]) - 2 * to_field(h4_0_0_3)))) - 2 * to_field(h4_0_1_2))), u8_from_field_unsafe(to_field(h4_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_3) + 128 * (to_field(t24_0[2]) - 2 * to_field(h4_0_0_4)))) - 2 * to_field(h4_0_1_3))), u8_from_field_unsafe(to_field(h4_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_4) + 128 * (to_field(t24_0[3]) - 2 * to_field(h4_0_0_5)))) - 2 * to_field(h4_0_1_4))), u8_from_field_unsafe(to_field(h4_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_5) + 128 * (to_field(t24_0[4]) - 2 * to_field(h4_0_0_6)))) - 2 * to_field(h4_0_1_5))), u8_from_field_unsafe(to_field(h4_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_6) + 128 * (to_field(t24_0[5]) - 2 * to_field(h4_0_0_7)))) - 2 * to_field(h4_0_1_6))), u8_from_field_unsafe(to_field(h4_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_7) + 128 * (to_field(t24_0[6]) - 2 * to_field(h4_0_0_0)))) - 2 * to_field(h4_0_1_7))), u8_from_field_unsafe(to_field(h4_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_0) + 128 * (to_field(t24_0[7]) - 2 * to_field(h4_0_0_1)))) - 2 * to_field(h4_0_1_0)))];
+      -- round 0: chi
+      let e0_0 = [u8_xor(b0_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[0])), b2_0[0])), u8_xor(b0_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[1])), b2_0[1])), u8_xor(b0_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[2])), b2_0[2])), u8_xor(b0_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[3])), b2_0[3])), u8_xor(b0_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[4])), b2_0[4])), u8_xor(b0_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[5])), b2_0[5])), u8_xor(b0_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[6])), b2_0[6])), u8_xor(b0_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[7])), b2_0[7]))];
+      let e1_0 = [u8_xor(b1_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[0])), b3_0[0])), u8_xor(b1_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[1])), b3_0[1])), u8_xor(b1_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[2])), b3_0[2])), u8_xor(b1_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[3])), b3_0[3])), u8_xor(b1_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[4])), b3_0[4])), u8_xor(b1_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[5])), b3_0[5])), u8_xor(b1_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[6])), b3_0[6])), u8_xor(b1_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[7])), b3_0[7]))];
+      let e2_0 = [u8_xor(b2_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[0])), b4_0[0])), u8_xor(b2_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[1])), b4_0[1])), u8_xor(b2_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[2])), b4_0[2])), u8_xor(b2_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[3])), b4_0[3])), u8_xor(b2_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[4])), b4_0[4])), u8_xor(b2_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[5])), b4_0[5])), u8_xor(b2_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[6])), b4_0[6])), u8_xor(b2_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[7])), b4_0[7]))];
+      let e3_0 = [u8_xor(b3_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[0])), b0_0[0])), u8_xor(b3_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[1])), b0_0[1])), u8_xor(b3_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[2])), b0_0[2])), u8_xor(b3_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[3])), b0_0[3])), u8_xor(b3_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[4])), b0_0[4])), u8_xor(b3_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[5])), b0_0[5])), u8_xor(b3_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[6])), b0_0[6])), u8_xor(b3_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[7])), b0_0[7]))];
+      let e4_0 = [u8_xor(b4_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[0])), b1_0[0])), u8_xor(b4_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[1])), b1_0[1])), u8_xor(b4_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[2])), b1_0[2])), u8_xor(b4_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[3])), b1_0[3])), u8_xor(b4_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[4])), b1_0[4])), u8_xor(b4_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[5])), b1_0[5])), u8_xor(b4_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[6])), b1_0[6])), u8_xor(b4_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[7])), b1_0[7]))];
+      let e5_0 = [u8_xor(b5_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[0])), b7_0[0])), u8_xor(b5_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[1])), b7_0[1])), u8_xor(b5_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[2])), b7_0[2])), u8_xor(b5_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[3])), b7_0[3])), u8_xor(b5_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[4])), b7_0[4])), u8_xor(b5_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[5])), b7_0[5])), u8_xor(b5_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[6])), b7_0[6])), u8_xor(b5_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[7])), b7_0[7]))];
+      let e6_0 = [u8_xor(b6_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[0])), b8_0[0])), u8_xor(b6_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[1])), b8_0[1])), u8_xor(b6_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[2])), b8_0[2])), u8_xor(b6_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[3])), b8_0[3])), u8_xor(b6_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[4])), b8_0[4])), u8_xor(b6_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[5])), b8_0[5])), u8_xor(b6_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[6])), b8_0[6])), u8_xor(b6_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[7])), b8_0[7]))];
+      let e7_0 = [u8_xor(b7_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[0])), b9_0[0])), u8_xor(b7_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[1])), b9_0[1])), u8_xor(b7_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[2])), b9_0[2])), u8_xor(b7_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[3])), b9_0[3])), u8_xor(b7_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[4])), b9_0[4])), u8_xor(b7_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[5])), b9_0[5])), u8_xor(b7_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[6])), b9_0[6])), u8_xor(b7_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[7])), b9_0[7]))];
+      let e8_0 = [u8_xor(b8_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[0])), b5_0[0])), u8_xor(b8_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[1])), b5_0[1])), u8_xor(b8_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[2])), b5_0[2])), u8_xor(b8_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[3])), b5_0[3])), u8_xor(b8_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[4])), b5_0[4])), u8_xor(b8_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[5])), b5_0[5])), u8_xor(b8_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[6])), b5_0[6])), u8_xor(b8_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[7])), b5_0[7]))];
+      let e9_0 = [u8_xor(b9_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[0])), b6_0[0])), u8_xor(b9_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[1])), b6_0[1])), u8_xor(b9_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[2])), b6_0[2])), u8_xor(b9_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[3])), b6_0[3])), u8_xor(b9_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[4])), b6_0[4])), u8_xor(b9_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[5])), b6_0[5])), u8_xor(b9_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[6])), b6_0[6])), u8_xor(b9_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[7])), b6_0[7]))];
+      let e10_0 = [u8_xor(b10_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[0])), b12_0[0])), u8_xor(b10_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[1])), b12_0[1])), u8_xor(b10_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[2])), b12_0[2])), u8_xor(b10_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[3])), b12_0[3])), u8_xor(b10_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[4])), b12_0[4])), u8_xor(b10_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[5])), b12_0[5])), u8_xor(b10_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[6])), b12_0[6])), u8_xor(b10_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[7])), b12_0[7]))];
+      let e11_0 = [u8_xor(b11_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[0])), b13_0[0])), u8_xor(b11_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[1])), b13_0[1])), u8_xor(b11_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[2])), b13_0[2])), u8_xor(b11_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[3])), b13_0[3])), u8_xor(b11_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[4])), b13_0[4])), u8_xor(b11_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[5])), b13_0[5])), u8_xor(b11_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[6])), b13_0[6])), u8_xor(b11_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[7])), b13_0[7]))];
+      let e12_0 = [u8_xor(b12_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[0])), b14_0[0])), u8_xor(b12_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[1])), b14_0[1])), u8_xor(b12_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[2])), b14_0[2])), u8_xor(b12_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[3])), b14_0[3])), u8_xor(b12_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[4])), b14_0[4])), u8_xor(b12_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[5])), b14_0[5])), u8_xor(b12_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[6])), b14_0[6])), u8_xor(b12_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[7])), b14_0[7]))];
+      let e13_0 = [u8_xor(b13_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[0])), b10_0[0])), u8_xor(b13_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[1])), b10_0[1])), u8_xor(b13_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[2])), b10_0[2])), u8_xor(b13_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[3])), b10_0[3])), u8_xor(b13_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[4])), b10_0[4])), u8_xor(b13_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[5])), b10_0[5])), u8_xor(b13_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[6])), b10_0[6])), u8_xor(b13_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[7])), b10_0[7]))];
+      let e14_0 = [u8_xor(b14_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[0])), b11_0[0])), u8_xor(b14_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[1])), b11_0[1])), u8_xor(b14_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[2])), b11_0[2])), u8_xor(b14_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[3])), b11_0[3])), u8_xor(b14_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[4])), b11_0[4])), u8_xor(b14_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[5])), b11_0[5])), u8_xor(b14_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[6])), b11_0[6])), u8_xor(b14_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[7])), b11_0[7]))];
+      let e15_0 = [u8_xor(b15_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[0])), b17_0[0])), u8_xor(b15_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[1])), b17_0[1])), u8_xor(b15_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[2])), b17_0[2])), u8_xor(b15_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[3])), b17_0[3])), u8_xor(b15_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[4])), b17_0[4])), u8_xor(b15_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[5])), b17_0[5])), u8_xor(b15_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[6])), b17_0[6])), u8_xor(b15_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[7])), b17_0[7]))];
+      let e16_0 = [u8_xor(b16_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[0])), b18_0[0])), u8_xor(b16_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[1])), b18_0[1])), u8_xor(b16_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[2])), b18_0[2])), u8_xor(b16_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[3])), b18_0[3])), u8_xor(b16_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[4])), b18_0[4])), u8_xor(b16_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[5])), b18_0[5])), u8_xor(b16_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[6])), b18_0[6])), u8_xor(b16_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[7])), b18_0[7]))];
+      let e17_0 = [u8_xor(b17_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[0])), b19_0[0])), u8_xor(b17_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[1])), b19_0[1])), u8_xor(b17_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[2])), b19_0[2])), u8_xor(b17_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[3])), b19_0[3])), u8_xor(b17_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[4])), b19_0[4])), u8_xor(b17_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[5])), b19_0[5])), u8_xor(b17_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[6])), b19_0[6])), u8_xor(b17_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[7])), b19_0[7]))];
+      let e18_0 = [u8_xor(b18_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[0])), b15_0[0])), u8_xor(b18_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[1])), b15_0[1])), u8_xor(b18_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[2])), b15_0[2])), u8_xor(b18_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[3])), b15_0[3])), u8_xor(b18_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[4])), b15_0[4])), u8_xor(b18_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[5])), b15_0[5])), u8_xor(b18_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[6])), b15_0[6])), u8_xor(b18_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[7])), b15_0[7]))];
+      let e19_0 = [u8_xor(b19_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[0])), b16_0[0])), u8_xor(b19_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[1])), b16_0[1])), u8_xor(b19_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[2])), b16_0[2])), u8_xor(b19_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[3])), b16_0[3])), u8_xor(b19_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[4])), b16_0[4])), u8_xor(b19_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[5])), b16_0[5])), u8_xor(b19_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[6])), b16_0[6])), u8_xor(b19_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[7])), b16_0[7]))];
+      let e20_0 = [u8_xor(b20_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[0])), b22_0[0])), u8_xor(b20_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[1])), b22_0[1])), u8_xor(b20_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[2])), b22_0[2])), u8_xor(b20_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[3])), b22_0[3])), u8_xor(b20_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[4])), b22_0[4])), u8_xor(b20_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[5])), b22_0[5])), u8_xor(b20_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[6])), b22_0[6])), u8_xor(b20_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[7])), b22_0[7]))];
+      let e21_0 = [u8_xor(b21_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[0])), b23_0[0])), u8_xor(b21_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[1])), b23_0[1])), u8_xor(b21_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[2])), b23_0[2])), u8_xor(b21_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[3])), b23_0[3])), u8_xor(b21_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[4])), b23_0[4])), u8_xor(b21_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[5])), b23_0[5])), u8_xor(b21_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[6])), b23_0[6])), u8_xor(b21_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[7])), b23_0[7]))];
+      let e22_0 = [u8_xor(b22_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[0])), b24_0[0])), u8_xor(b22_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[1])), b24_0[1])), u8_xor(b22_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[2])), b24_0[2])), u8_xor(b22_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[3])), b24_0[3])), u8_xor(b22_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[4])), b24_0[4])), u8_xor(b22_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[5])), b24_0[5])), u8_xor(b22_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[6])), b24_0[6])), u8_xor(b22_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[7])), b24_0[7]))];
+      let e23_0 = [u8_xor(b23_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[0])), b20_0[0])), u8_xor(b23_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[1])), b20_0[1])), u8_xor(b23_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[2])), b20_0[2])), u8_xor(b23_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[3])), b20_0[3])), u8_xor(b23_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[4])), b20_0[4])), u8_xor(b23_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[5])), b20_0[5])), u8_xor(b23_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[6])), b20_0[6])), u8_xor(b23_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[7])), b20_0[7]))];
+      let e24_0 = [u8_xor(b24_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[0])), b21_0[0])), u8_xor(b24_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[1])), b21_0[1])), u8_xor(b24_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[2])), b21_0[2])), u8_xor(b24_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[3])), b21_0[3])), u8_xor(b24_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[4])), b21_0[4])), u8_xor(b24_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[5])), b21_0[5])), u8_xor(b24_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[6])), b21_0[6])), u8_xor(b24_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[7])), b21_0[7]))];
+      -- round 0: iota
+      let f0_0 = [u8_xor(e0_0[0], rc0[0]), u8_xor(e0_0[1], rc0[1]), u8_xor(e0_0[2], rc0[2]), u8_xor(e0_0[3], rc0[3]), u8_xor(e0_0[4], rc0[4]), u8_xor(e0_0[5], rc0[5]), u8_xor(e0_0[6], rc0[6]), u8_xor(e0_0[7], rc0[7])];
+      let s1 = [f0_0, e1_0, e2_0, e3_0, e4_0, e5_0, e6_0, e7_0, e8_0, e9_0, e10_0, e11_0, e12_0, e13_0, e14_0, e15_0, e16_0, e17_0, e18_0, e19_0, e20_0, e21_0, e22_0, e23_0, e24_0];
+      s1
   }
 ⟧
 

From 2d7962ccb238401c03c1809318796288c7907d9a Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sat, 11 Jul 2026 10:45:13 -0700
Subject: [PATCH 13/22] Aiur keccak: one permutation circuit via inlined round
 calls
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

keccak_f now applies the round 24 times as `@keccak_round(s, rc)`
inlined calls, so all 24 rounds splice into a single straight-line
circuit: one row per keccak-f call (height = block count, 16 for a
2048-byte message) instead of the round circuit's height 384 (24
rounds x 16 permutations). The log2(height) factor drops from ~8.6 to
4, and the per-round state-rematerialization interface disappears.

The round body is written once (still script-generated for the 24
distinct rho+pi bit wirings); the elaborator only ever sees one round
plus 24 call sites, so the earlier stack overflow / >30-min unroll is
gone — the 24x expansion happens in the compiler's inline pass at
compile time, not in Lean elaboration. Build stays ~4s.

Probe (1 hash, 2048 bytes, non-periodic LCG): 14,303,230 ->
6,723,868 (-53%), now within 2% of blake3 (6,575,392) on the same
input — 210x below the original MultiStark implementation. keccak_f
is one circuit, width 89,678 x height 16. `aiur-hashes` keccak cases
green including prove/verify, against the Rust FFI oracle.
---
 Ix/IxVM/Keccak.lean | 57 ++++++++++++++++++++++++---------------------
 1 file changed, 31 insertions(+), 26 deletions(-)

diff --git a/Ix/IxVM/Keccak.lean b/Ix/IxVM/Keccak.lean
index 1fe57799..ea9e06e6 100644
--- a/Ix/IxVM/Keccak.lean
+++ b/Ix/IxVM/Keccak.lean
@@ -134,36 +134,41 @@ def keccak := ⟦
     [s[0], s[1], s[2], s[3]]
   }
 
-  /- # keccak-f[1600]: 24 rounds of theta-rho-pi-chi-iota, 1 per keccak_roundN circuit (height = 384/1) -/
+  /- # keccak-f[1600]: 24 rounds of theta-rho-pi-chi-iota.
+     Each `@keccak_round` is an INLINED call: the compiler splices the
+     round body into keccak_f, so all 24 rounds share one circuit (one
+     row per permutation, height = block count) with no per-round call
+     interface. The round is written once; the elaborator only sees a
+     single round body plus 24 call sites. -/
 
   fn keccak_f(s: [[U8; 8]; 25]) -> [[U8; 8]; 25] {
-    let s = keccak_roundN(s, [0x01u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_roundN(s, [0x82u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_roundN(s, [0x8au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_roundN(s, [0u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_roundN(s, [0x8bu8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_roundN(s, [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_roundN(s, [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_roundN(s, [0x09u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_roundN(s, [0x8au8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_roundN(s, [0x88u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_roundN(s, [0x09u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_roundN(s, [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_roundN(s, [0x8bu8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_roundN(s, [0x8bu8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_roundN(s, [0x89u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_roundN(s, [0x03u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_roundN(s, [0x02u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_roundN(s, [0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_roundN(s, [0x0au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_roundN(s, [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_roundN(s, [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_roundN(s, [0x80u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_roundN(s, [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    keccak_roundN(s, [0x08u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8])
+    let s = @keccak_round(s, [0x01u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = @keccak_round(s, [0x82u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = @keccak_round(s, [0x8au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = @keccak_round(s, [0u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = @keccak_round(s, [0x8bu8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = @keccak_round(s, [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = @keccak_round(s, [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = @keccak_round(s, [0x09u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = @keccak_round(s, [0x8au8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = @keccak_round(s, [0x88u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = @keccak_round(s, [0x09u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = @keccak_round(s, [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = @keccak_round(s, [0x8bu8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = @keccak_round(s, [0x8bu8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = @keccak_round(s, [0x89u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = @keccak_round(s, [0x03u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = @keccak_round(s, [0x02u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = @keccak_round(s, [0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = @keccak_round(s, [0x0au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = @keccak_round(s, [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = @keccak_round(s, [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = @keccak_round(s, [0x80u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = @keccak_round(s, [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    @keccak_round(s, [0x08u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8])
   }
 
-  fn keccak_roundN(s0: [[U8; 8]; 25], rc0: [U8; 8]) -> [[U8; 8]; 25] {
+  fn keccak_round(s0: [[U8; 8]; 25], rc0: [U8; 8]) -> [[U8; 8]; 25] {
       -- round 0: theta
       let c0_0 = [u8_xor(s0[20][0], u8_xor(s0[15][0], u8_xor(s0[10][0], u8_xor(s0[5][0], s0[0][0])))), u8_xor(s0[20][1], u8_xor(s0[15][1], u8_xor(s0[10][1], u8_xor(s0[5][1], s0[0][1])))), u8_xor(s0[20][2], u8_xor(s0[15][2], u8_xor(s0[10][2], u8_xor(s0[5][2], s0[0][2])))), u8_xor(s0[20][3], u8_xor(s0[15][3], u8_xor(s0[10][3], u8_xor(s0[5][3], s0[0][3])))), u8_xor(s0[20][4], u8_xor(s0[15][4], u8_xor(s0[10][4], u8_xor(s0[5][4], s0[0][4])))), u8_xor(s0[20][5], u8_xor(s0[15][5], u8_xor(s0[10][5], u8_xor(s0[5][5], s0[0][5])))), u8_xor(s0[20][6], u8_xor(s0[15][6], u8_xor(s0[10][6], u8_xor(s0[5][6], s0[0][6])))), u8_xor(s0[20][7], u8_xor(s0[15][7], u8_xor(s0[10][7], u8_xor(s0[5][7], s0[0][7]))))];
       let c1_0 = [u8_xor(s0[21][0], u8_xor(s0[16][0], u8_xor(s0[11][0], u8_xor(s0[6][0], s0[1][0])))), u8_xor(s0[21][1], u8_xor(s0[16][1], u8_xor(s0[11][1], u8_xor(s0[6][1], s0[1][1])))), u8_xor(s0[21][2], u8_xor(s0[16][2], u8_xor(s0[11][2], u8_xor(s0[6][2], s0[1][2])))), u8_xor(s0[21][3], u8_xor(s0[16][3], u8_xor(s0[11][3], u8_xor(s0[6][3], s0[1][3])))), u8_xor(s0[21][4], u8_xor(s0[16][4], u8_xor(s0[11][4], u8_xor(s0[6][4], s0[1][4])))), u8_xor(s0[21][5], u8_xor(s0[16][5], u8_xor(s0[11][5], u8_xor(s0[6][5], s0[1][5])))), u8_xor(s0[21][6], u8_xor(s0[16][6], u8_xor(s0[11][6], u8_xor(s0[6][6], s0[1][6])))), u8_xor(s0[21][7], u8_xor(s0[16][7], u8_xor(s0[11][7], u8_xor(s0[6][7], s0[1][7]))))];

From 61da2e3a0cd85ffc3361291b2d67204867c733af Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sat, 11 Jul 2026 12:10:43 -0700
Subject: [PATCH 14/22] Aiur keccak: extract round byte-ops into readable
 @-inlined helpers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The round body was a wall of inlined byte arithmetic (5-deep u8_xor
nests, per-lane rotation recompositions, chi's not/and/xor blobs). With
`@`-inlined calls costing nothing, factor it into named helpers — xor8,
and8, not8, rotl1, chi_lane, and one rotl_N per distinct rho offset —
and write keccak_round as legible dataflow calling them `@`-inlined. The
whole permutation still compiles to a single circuit.

Same probe (1 hash, 2048 bytes, non-periodic LCG): 6,723,868 FFT,
byte-identical to the hand-inlined version — extraction is free.
`aiur-hashes` keccak cases green (execute/claim/prove-verify) against
the Rust FFI oracle.
---
 Ix/IxVM/Keccak.lean | 1039 +++++++++++++++++++++++--------------------
 1 file changed, 550 insertions(+), 489 deletions(-)

diff --git a/Ix/IxVM/Keccak.lean b/Ix/IxVM/Keccak.lean
index ea9e06e6..9ea7f17c 100644
--- a/Ix/IxVM/Keccak.lean
+++ b/Ix/IxVM/Keccak.lean
@@ -134,12 +134,464 @@ def keccak := ⟦
     [s[0], s[1], s[2], s[3]]
   }
 
-  /- # keccak-f[1600]: 24 rounds of theta-rho-pi-chi-iota.
-     Each `@keccak_round` is an INLINED call: the compiler splices the
-     round body into keccak_f, so all 24 rounds share one circuit (one
-     row per permutation, height = block count) with no per-round call
-     interface. The round is written once; the elaborator only sees a
-     single round body plus 24 call sites. -/
+  /- # Byte-op helpers (all `@`-inlined into keccak_round). -/
+
+  -- Bytewise XOR / AND of two lanes.
+  fn xor8(a: [U8; 8], b: [U8; 8]) -> [U8; 8] {
+    [u8_xor(a[0], b[0]), u8_xor(a[1], b[1]), u8_xor(a[2], b[2]), u8_xor(a[3], b[3]), u8_xor(a[4], b[4]), u8_xor(a[5], b[5]), u8_xor(a[6], b[6]), u8_xor(a[7], b[7])]
+  }
+
+  fn and8(a: [U8; 8], b: [U8; 8]) -> [U8; 8] {
+    [u8_and(a[0], b[0]), u8_and(a[1], b[1]), u8_and(a[2], b[2]), u8_and(a[3], b[3]), u8_and(a[4], b[4]), u8_and(a[5], b[5]), u8_and(a[6], b[6]), u8_and(a[7], b[7])]
+  }
+
+  -- Bitwise NOT as the free recomposition 255 - b.
+  fn not8(a: [U8; 8]) -> [U8; 8] {
+    [u8_from_field_unsafe(255 - to_field(a[0])), u8_from_field_unsafe(255 - to_field(a[1])), u8_from_field_unsafe(255 - to_field(a[2])), u8_from_field_unsafe(255 - to_field(a[3])), u8_from_field_unsafe(255 - to_field(a[4])), u8_from_field_unsafe(255 - to_field(a[5])), u8_from_field_unsafe(255 - to_field(a[6])), u8_from_field_unsafe(255 - to_field(a[7]))]
+  }
+
+  -- chi lane: b0 ^ (~b1 & b2).
+  fn chi_lane(b0: [U8; 8], b1: [U8; 8], b2: [U8; 8]) -> [U8; 8] {
+    @xor8(b0, @and8(@not8(b1), b2))
+  }
+
+  -- theta's rotl-by-1 of a column parity, via the u8_add doubling trick:
+  -- (b + b) = (2b mod 256, msb); the even low byte absorbs the neighbor's
+  -- msb through a free field add.
+  fn rotl1(l: [U8; 8]) -> [U8; 8] {
+    let (a0, m0) = u8_add(l[0], l[0]);
+    let (a1, m1) = u8_add(l[1], l[1]);
+    let (a2, m2) = u8_add(l[2], l[2]);
+    let (a3, m3) = u8_add(l[3], l[3]);
+    let (a4, m4) = u8_add(l[4], l[4]);
+    let (a5, m5) = u8_add(l[5], l[5]);
+    let (a6, m6) = u8_add(l[6], l[6]);
+    let (a7, m7) = u8_add(l[7], l[7]);
+    [u8_from_field_unsafe(to_field(a0) + to_field(m7)), u8_from_field_unsafe(to_field(a1) + to_field(m0)), u8_from_field_unsafe(to_field(a2) + to_field(m1)), u8_from_field_unsafe(to_field(a3) + to_field(m2)), u8_from_field_unsafe(to_field(a4) + to_field(m3)), u8_from_field_unsafe(to_field(a5) + to_field(m4)), u8_from_field_unsafe(to_field(a6) + to_field(m5)), u8_from_field_unsafe(to_field(a7) + to_field(m6))]
+  }
+
+  /- # rho rotations: one `rotl_N` per distinct offset (bit recomposition;
+     multiples of 8 are byte shuffles, others chain the u8_add / u8_shift
+     tricks). All `@`-inlined. -/
+
+  fn rotl_1(l: [U8; 8]) -> [U8; 8] {
+    let (a0_0, c0_0) = u8_add(l[0], l[0]);
+    let (a0_1, c0_1) = u8_add(l[1], l[1]);
+    let (a0_2, c0_2) = u8_add(l[2], l[2]);
+    let (a0_3, c0_3) = u8_add(l[3], l[3]);
+    let (a0_4, c0_4) = u8_add(l[4], l[4]);
+    let (a0_5, c0_5) = u8_add(l[5], l[5]);
+    let (a0_6, c0_6) = u8_add(l[6], l[6]);
+    let (a0_7, c0_7) = u8_add(l[7], l[7]);
+    [u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6))]
+  }
+
+  fn rotl_2(l: [U8; 8]) -> [U8; 8] {
+    let (a0_0, c0_0) = u8_add(l[0], l[0]);
+    let (a0_1, c0_1) = u8_add(l[1], l[1]);
+    let (a0_2, c0_2) = u8_add(l[2], l[2]);
+    let (a0_3, c0_3) = u8_add(l[3], l[3]);
+    let (a0_4, c0_4) = u8_add(l[4], l[4]);
+    let (a0_5, c0_5) = u8_add(l[5], l[5]);
+    let (a0_6, c0_6) = u8_add(l[6], l[6]);
+    let (a0_7, c0_7) = u8_add(l[7], l[7]);
+    let (a1_0, c1_0) = u8_add(u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)));
+    let (a1_1, c1_1) = u8_add(u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)));
+    let (a1_2, c1_2) = u8_add(u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)));
+    let (a1_3, c1_3) = u8_add(u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)));
+    let (a1_4, c1_4) = u8_add(u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)));
+    let (a1_5, c1_5) = u8_add(u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)));
+    let (a1_6, c1_6) = u8_add(u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)));
+    let (a1_7, c1_7) = u8_add(u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)));
+    [u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)), u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)), u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)), u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)), u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)), u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)), u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)), u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6))]
+  }
+
+  fn rotl_3(l: [U8; 8]) -> [U8; 8] {
+    let (a0_0, c0_0) = u8_add(l[0], l[0]);
+    let (a0_1, c0_1) = u8_add(l[1], l[1]);
+    let (a0_2, c0_2) = u8_add(l[2], l[2]);
+    let (a0_3, c0_3) = u8_add(l[3], l[3]);
+    let (a0_4, c0_4) = u8_add(l[4], l[4]);
+    let (a0_5, c0_5) = u8_add(l[5], l[5]);
+    let (a0_6, c0_6) = u8_add(l[6], l[6]);
+    let (a0_7, c0_7) = u8_add(l[7], l[7]);
+    let (a1_0, c1_0) = u8_add(u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)));
+    let (a1_1, c1_1) = u8_add(u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)));
+    let (a1_2, c1_2) = u8_add(u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)));
+    let (a1_3, c1_3) = u8_add(u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)));
+    let (a1_4, c1_4) = u8_add(u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)));
+    let (a1_5, c1_5) = u8_add(u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)));
+    let (a1_6, c1_6) = u8_add(u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)));
+    let (a1_7, c1_7) = u8_add(u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)));
+    let (a2_0, c2_0) = u8_add(u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)), u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)));
+    let (a2_1, c2_1) = u8_add(u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)), u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)));
+    let (a2_2, c2_2) = u8_add(u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)), u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)));
+    let (a2_3, c2_3) = u8_add(u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)), u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)));
+    let (a2_4, c2_4) = u8_add(u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)), u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)));
+    let (a2_5, c2_5) = u8_add(u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)), u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)));
+    let (a2_6, c2_6) = u8_add(u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)), u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)));
+    let (a2_7, c2_7) = u8_add(u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6)), u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6)));
+    [u8_from_field_unsafe(to_field(a2_0) + to_field(c2_7)), u8_from_field_unsafe(to_field(a2_1) + to_field(c2_0)), u8_from_field_unsafe(to_field(a2_2) + to_field(c2_1)), u8_from_field_unsafe(to_field(a2_3) + to_field(c2_2)), u8_from_field_unsafe(to_field(a2_4) + to_field(c2_3)), u8_from_field_unsafe(to_field(a2_5) + to_field(c2_4)), u8_from_field_unsafe(to_field(a2_6) + to_field(c2_5)), u8_from_field_unsafe(to_field(a2_7) + to_field(c2_6))]
+  }
+
+  fn rotl_6(l: [U8; 8]) -> [U8; 8] {
+    let h0_0 = u8_shift_right(l[7]);
+    let h0_1 = u8_shift_right(l[0]);
+    let h0_2 = u8_shift_right(l[1]);
+    let h0_3 = u8_shift_right(l[2]);
+    let h0_4 = u8_shift_right(l[3]);
+    let h0_5 = u8_shift_right(l[4]);
+    let h0_6 = u8_shift_right(l[5]);
+    let h0_7 = u8_shift_right(l[6]);
+    let h1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[0]) - 2 * to_field(h0_1))));
+    let h1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[1]) - 2 * to_field(h0_2))));
+    let h1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[2]) - 2 * to_field(h0_3))));
+    let h1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[3]) - 2 * to_field(h0_4))));
+    let h1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[4]) - 2 * to_field(h0_5))));
+    let h1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[5]) - 2 * to_field(h0_6))));
+    let h1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[6]) - 2 * to_field(h0_7))));
+    let h1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[7]) - 2 * to_field(h0_0))));
+    [u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[1]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1))), u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[2]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2))), u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[3]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3))), u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[4]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4))), u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[5]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5))), u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[6]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6))), u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[7]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7))), u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[0]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0)))]
+  }
+
+  fn rotl_8(l: [U8; 8]) -> [U8; 8] {
+    [l[7], l[0], l[1], l[2], l[3], l[4], l[5], l[6]]
+  }
+
+  fn rotl_10(l: [U8; 8]) -> [U8; 8] {
+    let (a0_0, c0_0) = u8_add(l[7], l[7]);
+    let (a0_1, c0_1) = u8_add(l[0], l[0]);
+    let (a0_2, c0_2) = u8_add(l[1], l[1]);
+    let (a0_3, c0_3) = u8_add(l[2], l[2]);
+    let (a0_4, c0_4) = u8_add(l[3], l[3]);
+    let (a0_5, c0_5) = u8_add(l[4], l[4]);
+    let (a0_6, c0_6) = u8_add(l[5], l[5]);
+    let (a0_7, c0_7) = u8_add(l[6], l[6]);
+    let (a1_0, c1_0) = u8_add(u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)));
+    let (a1_1, c1_1) = u8_add(u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)));
+    let (a1_2, c1_2) = u8_add(u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)));
+    let (a1_3, c1_3) = u8_add(u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)));
+    let (a1_4, c1_4) = u8_add(u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)));
+    let (a1_5, c1_5) = u8_add(u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)));
+    let (a1_6, c1_6) = u8_add(u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)));
+    let (a1_7, c1_7) = u8_add(u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)));
+    [u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)), u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)), u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)), u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)), u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)), u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)), u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)), u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6))]
+  }
+
+  fn rotl_14(l: [U8; 8]) -> [U8; 8] {
+    let h0_0 = u8_shift_right(l[6]);
+    let h0_1 = u8_shift_right(l[7]);
+    let h0_2 = u8_shift_right(l[0]);
+    let h0_3 = u8_shift_right(l[1]);
+    let h0_4 = u8_shift_right(l[2]);
+    let h0_5 = u8_shift_right(l[3]);
+    let h0_6 = u8_shift_right(l[4]);
+    let h0_7 = u8_shift_right(l[5]);
+    let h1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[7]) - 2 * to_field(h0_1))));
+    let h1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[0]) - 2 * to_field(h0_2))));
+    let h1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[1]) - 2 * to_field(h0_3))));
+    let h1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[2]) - 2 * to_field(h0_4))));
+    let h1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[3]) - 2 * to_field(h0_5))));
+    let h1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[4]) - 2 * to_field(h0_6))));
+    let h1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[5]) - 2 * to_field(h0_7))));
+    let h1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[6]) - 2 * to_field(h0_0))));
+    [u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[0]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1))), u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[1]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2))), u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[2]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3))), u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[3]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4))), u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[4]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5))), u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[5]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6))), u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[6]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7))), u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[7]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0)))]
+  }
+
+  fn rotl_15(l: [U8; 8]) -> [U8; 8] {
+    let h0_0 = u8_shift_right(l[6]);
+    let h0_1 = u8_shift_right(l[7]);
+    let h0_2 = u8_shift_right(l[0]);
+    let h0_3 = u8_shift_right(l[1]);
+    let h0_4 = u8_shift_right(l[2]);
+    let h0_5 = u8_shift_right(l[3]);
+    let h0_6 = u8_shift_right(l[4]);
+    let h0_7 = u8_shift_right(l[5]);
+    [u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[7]) - 2 * to_field(h0_1))), u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[0]) - 2 * to_field(h0_2))), u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[1]) - 2 * to_field(h0_3))), u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[2]) - 2 * to_field(h0_4))), u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[3]) - 2 * to_field(h0_5))), u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[4]) - 2 * to_field(h0_6))), u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[5]) - 2 * to_field(h0_7))), u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[6]) - 2 * to_field(h0_0)))]
+  }
+
+  fn rotl_18(l: [U8; 8]) -> [U8; 8] {
+    let (a0_0, c0_0) = u8_add(l[6], l[6]);
+    let (a0_1, c0_1) = u8_add(l[7], l[7]);
+    let (a0_2, c0_2) = u8_add(l[0], l[0]);
+    let (a0_3, c0_3) = u8_add(l[1], l[1]);
+    let (a0_4, c0_4) = u8_add(l[2], l[2]);
+    let (a0_5, c0_5) = u8_add(l[3], l[3]);
+    let (a0_6, c0_6) = u8_add(l[4], l[4]);
+    let (a0_7, c0_7) = u8_add(l[5], l[5]);
+    let (a1_0, c1_0) = u8_add(u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)));
+    let (a1_1, c1_1) = u8_add(u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)));
+    let (a1_2, c1_2) = u8_add(u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)));
+    let (a1_3, c1_3) = u8_add(u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)));
+    let (a1_4, c1_4) = u8_add(u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)));
+    let (a1_5, c1_5) = u8_add(u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)));
+    let (a1_6, c1_6) = u8_add(u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)));
+    let (a1_7, c1_7) = u8_add(u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)));
+    [u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)), u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)), u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)), u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)), u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)), u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)), u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)), u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6))]
+  }
+
+  fn rotl_20(l: [U8; 8]) -> [U8; 8] {
+    let d0 = u8_bit_decomposition(l[0]);
+    let d1 = u8_bit_decomposition(l[1]);
+    let d2 = u8_bit_decomposition(l[2]);
+    let d3 = u8_bit_decomposition(l[3]);
+    let d4 = u8_bit_decomposition(l[4]);
+    let d5 = u8_bit_decomposition(l[5]);
+    let d6 = u8_bit_decomposition(l[6]);
+    let d7 = u8_bit_decomposition(l[7]);
+    [u8_from_field_unsafe(d5[4] + 2 * d5[5] + 4 * d5[6] + 8 * d5[7] + 16 * d6[0] + 32 * d6[1] + 64 * d6[2] + 128 * d6[3]), u8_from_field_unsafe(d6[4] + 2 * d6[5] + 4 * d6[6] + 8 * d6[7] + 16 * d7[0] + 32 * d7[1] + 64 * d7[2] + 128 * d7[3]), u8_from_field_unsafe(d7[4] + 2 * d7[5] + 4 * d7[6] + 8 * d7[7] + 16 * d0[0] + 32 * d0[1] + 64 * d0[2] + 128 * d0[3]), u8_from_field_unsafe(d0[4] + 2 * d0[5] + 4 * d0[6] + 8 * d0[7] + 16 * d1[0] + 32 * d1[1] + 64 * d1[2] + 128 * d1[3]), u8_from_field_unsafe(d1[4] + 2 * d1[5] + 4 * d1[6] + 8 * d1[7] + 16 * d2[0] + 32 * d2[1] + 64 * d2[2] + 128 * d2[3]), u8_from_field_unsafe(d2[4] + 2 * d2[5] + 4 * d2[6] + 8 * d2[7] + 16 * d3[0] + 32 * d3[1] + 64 * d3[2] + 128 * d3[3]), u8_from_field_unsafe(d3[4] + 2 * d3[5] + 4 * d3[6] + 8 * d3[7] + 16 * d4[0] + 32 * d4[1] + 64 * d4[2] + 128 * d4[3]), u8_from_field_unsafe(d4[4] + 2 * d4[5] + 4 * d4[6] + 8 * d4[7] + 16 * d5[0] + 32 * d5[1] + 64 * d5[2] + 128 * d5[3])]
+  }
+
+  fn rotl_21(l: [U8; 8]) -> [U8; 8] {
+    let h0_0 = u8_shift_right(l[5]);
+    let h0_1 = u8_shift_right(l[6]);
+    let h0_2 = u8_shift_right(l[7]);
+    let h0_3 = u8_shift_right(l[0]);
+    let h0_4 = u8_shift_right(l[1]);
+    let h0_5 = u8_shift_right(l[2]);
+    let h0_6 = u8_shift_right(l[3]);
+    let h0_7 = u8_shift_right(l[4]);
+    let h1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[6]) - 2 * to_field(h0_1))));
+    let h1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[7]) - 2 * to_field(h0_2))));
+    let h1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[0]) - 2 * to_field(h0_3))));
+    let h1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[1]) - 2 * to_field(h0_4))));
+    let h1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[2]) - 2 * to_field(h0_5))));
+    let h1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[3]) - 2 * to_field(h0_6))));
+    let h1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[4]) - 2 * to_field(h0_7))));
+    let h1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[5]) - 2 * to_field(h0_0))));
+    let h2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[7]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1))));
+    let h2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[0]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2))));
+    let h2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[1]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3))));
+    let h2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[2]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4))));
+    let h2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[3]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5))));
+    let h2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[4]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6))));
+    let h2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[5]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7))));
+    let h2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[6]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0))));
+    [u8_from_field_unsafe(to_field(h2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[0]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2)))) - 2 * to_field(h2_1))), u8_from_field_unsafe(to_field(h2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[1]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3)))) - 2 * to_field(h2_2))), u8_from_field_unsafe(to_field(h2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[2]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4)))) - 2 * to_field(h2_3))), u8_from_field_unsafe(to_field(h2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[3]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5)))) - 2 * to_field(h2_4))), u8_from_field_unsafe(to_field(h2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[4]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6)))) - 2 * to_field(h2_5))), u8_from_field_unsafe(to_field(h2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[5]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7)))) - 2 * to_field(h2_6))), u8_from_field_unsafe(to_field(h2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[6]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0)))) - 2 * to_field(h2_7))), u8_from_field_unsafe(to_field(h2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[7]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1)))) - 2 * to_field(h2_0)))]
+  }
+
+  fn rotl_25(l: [U8; 8]) -> [U8; 8] {
+    let (a0_0, c0_0) = u8_add(l[5], l[5]);
+    let (a0_1, c0_1) = u8_add(l[6], l[6]);
+    let (a0_2, c0_2) = u8_add(l[7], l[7]);
+    let (a0_3, c0_3) = u8_add(l[0], l[0]);
+    let (a0_4, c0_4) = u8_add(l[1], l[1]);
+    let (a0_5, c0_5) = u8_add(l[2], l[2]);
+    let (a0_6, c0_6) = u8_add(l[3], l[3]);
+    let (a0_7, c0_7) = u8_add(l[4], l[4]);
+    [u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6))]
+  }
+
+  fn rotl_27(l: [U8; 8]) -> [U8; 8] {
+    let (a0_0, c0_0) = u8_add(l[5], l[5]);
+    let (a0_1, c0_1) = u8_add(l[6], l[6]);
+    let (a0_2, c0_2) = u8_add(l[7], l[7]);
+    let (a0_3, c0_3) = u8_add(l[0], l[0]);
+    let (a0_4, c0_4) = u8_add(l[1], l[1]);
+    let (a0_5, c0_5) = u8_add(l[2], l[2]);
+    let (a0_6, c0_6) = u8_add(l[3], l[3]);
+    let (a0_7, c0_7) = u8_add(l[4], l[4]);
+    let (a1_0, c1_0) = u8_add(u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)));
+    let (a1_1, c1_1) = u8_add(u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)));
+    let (a1_2, c1_2) = u8_add(u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)));
+    let (a1_3, c1_3) = u8_add(u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)));
+    let (a1_4, c1_4) = u8_add(u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)));
+    let (a1_5, c1_5) = u8_add(u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)));
+    let (a1_6, c1_6) = u8_add(u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)));
+    let (a1_7, c1_7) = u8_add(u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)));
+    let (a2_0, c2_0) = u8_add(u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)), u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)));
+    let (a2_1, c2_1) = u8_add(u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)), u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)));
+    let (a2_2, c2_2) = u8_add(u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)), u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)));
+    let (a2_3, c2_3) = u8_add(u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)), u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)));
+    let (a2_4, c2_4) = u8_add(u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)), u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)));
+    let (a2_5, c2_5) = u8_add(u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)), u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)));
+    let (a2_6, c2_6) = u8_add(u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)), u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)));
+    let (a2_7, c2_7) = u8_add(u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6)), u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6)));
+    [u8_from_field_unsafe(to_field(a2_0) + to_field(c2_7)), u8_from_field_unsafe(to_field(a2_1) + to_field(c2_0)), u8_from_field_unsafe(to_field(a2_2) + to_field(c2_1)), u8_from_field_unsafe(to_field(a2_3) + to_field(c2_2)), u8_from_field_unsafe(to_field(a2_4) + to_field(c2_3)), u8_from_field_unsafe(to_field(a2_5) + to_field(c2_4)), u8_from_field_unsafe(to_field(a2_6) + to_field(c2_5)), u8_from_field_unsafe(to_field(a2_7) + to_field(c2_6))]
+  }
+
+  fn rotl_28(l: [U8; 8]) -> [U8; 8] {
+    let d0 = u8_bit_decomposition(l[0]);
+    let d1 = u8_bit_decomposition(l[1]);
+    let d2 = u8_bit_decomposition(l[2]);
+    let d3 = u8_bit_decomposition(l[3]);
+    let d4 = u8_bit_decomposition(l[4]);
+    let d5 = u8_bit_decomposition(l[5]);
+    let d6 = u8_bit_decomposition(l[6]);
+    let d7 = u8_bit_decomposition(l[7]);
+    [u8_from_field_unsafe(d4[4] + 2 * d4[5] + 4 * d4[6] + 8 * d4[7] + 16 * d5[0] + 32 * d5[1] + 64 * d5[2] + 128 * d5[3]), u8_from_field_unsafe(d5[4] + 2 * d5[5] + 4 * d5[6] + 8 * d5[7] + 16 * d6[0] + 32 * d6[1] + 64 * d6[2] + 128 * d6[3]), u8_from_field_unsafe(d6[4] + 2 * d6[5] + 4 * d6[6] + 8 * d6[7] + 16 * d7[0] + 32 * d7[1] + 64 * d7[2] + 128 * d7[3]), u8_from_field_unsafe(d7[4] + 2 * d7[5] + 4 * d7[6] + 8 * d7[7] + 16 * d0[0] + 32 * d0[1] + 64 * d0[2] + 128 * d0[3]), u8_from_field_unsafe(d0[4] + 2 * d0[5] + 4 * d0[6] + 8 * d0[7] + 16 * d1[0] + 32 * d1[1] + 64 * d1[2] + 128 * d1[3]), u8_from_field_unsafe(d1[4] + 2 * d1[5] + 4 * d1[6] + 8 * d1[7] + 16 * d2[0] + 32 * d2[1] + 64 * d2[2] + 128 * d2[3]), u8_from_field_unsafe(d2[4] + 2 * d2[5] + 4 * d2[6] + 8 * d2[7] + 16 * d3[0] + 32 * d3[1] + 64 * d3[2] + 128 * d3[3]), u8_from_field_unsafe(d3[4] + 2 * d3[5] + 4 * d3[6] + 8 * d3[7] + 16 * d4[0] + 32 * d4[1] + 64 * d4[2] + 128 * d4[3])]
+  }
+
+  fn rotl_36(l: [U8; 8]) -> [U8; 8] {
+    let d0 = u8_bit_decomposition(l[0]);
+    let d1 = u8_bit_decomposition(l[1]);
+    let d2 = u8_bit_decomposition(l[2]);
+    let d3 = u8_bit_decomposition(l[3]);
+    let d4 = u8_bit_decomposition(l[4]);
+    let d5 = u8_bit_decomposition(l[5]);
+    let d6 = u8_bit_decomposition(l[6]);
+    let d7 = u8_bit_decomposition(l[7]);
+    [u8_from_field_unsafe(d3[4] + 2 * d3[5] + 4 * d3[6] + 8 * d3[7] + 16 * d4[0] + 32 * d4[1] + 64 * d4[2] + 128 * d4[3]), u8_from_field_unsafe(d4[4] + 2 * d4[5] + 4 * d4[6] + 8 * d4[7] + 16 * d5[0] + 32 * d5[1] + 64 * d5[2] + 128 * d5[3]), u8_from_field_unsafe(d5[4] + 2 * d5[5] + 4 * d5[6] + 8 * d5[7] + 16 * d6[0] + 32 * d6[1] + 64 * d6[2] + 128 * d6[3]), u8_from_field_unsafe(d6[4] + 2 * d6[5] + 4 * d6[6] + 8 * d6[7] + 16 * d7[0] + 32 * d7[1] + 64 * d7[2] + 128 * d7[3]), u8_from_field_unsafe(d7[4] + 2 * d7[5] + 4 * d7[6] + 8 * d7[7] + 16 * d0[0] + 32 * d0[1] + 64 * d0[2] + 128 * d0[3]), u8_from_field_unsafe(d0[4] + 2 * d0[5] + 4 * d0[6] + 8 * d0[7] + 16 * d1[0] + 32 * d1[1] + 64 * d1[2] + 128 * d1[3]), u8_from_field_unsafe(d1[4] + 2 * d1[5] + 4 * d1[6] + 8 * d1[7] + 16 * d2[0] + 32 * d2[1] + 64 * d2[2] + 128 * d2[3]), u8_from_field_unsafe(d2[4] + 2 * d2[5] + 4 * d2[6] + 8 * d2[7] + 16 * d3[0] + 32 * d3[1] + 64 * d3[2] + 128 * d3[3])]
+  }
+
+  fn rotl_39(l: [U8; 8]) -> [U8; 8] {
+    let h0_0 = u8_shift_right(l[3]);
+    let h0_1 = u8_shift_right(l[4]);
+    let h0_2 = u8_shift_right(l[5]);
+    let h0_3 = u8_shift_right(l[6]);
+    let h0_4 = u8_shift_right(l[7]);
+    let h0_5 = u8_shift_right(l[0]);
+    let h0_6 = u8_shift_right(l[1]);
+    let h0_7 = u8_shift_right(l[2]);
+    [u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[4]) - 2 * to_field(h0_1))), u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[5]) - 2 * to_field(h0_2))), u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[6]) - 2 * to_field(h0_3))), u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[7]) - 2 * to_field(h0_4))), u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[0]) - 2 * to_field(h0_5))), u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[1]) - 2 * to_field(h0_6))), u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[2]) - 2 * to_field(h0_7))), u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[3]) - 2 * to_field(h0_0)))]
+  }
+
+  fn rotl_41(l: [U8; 8]) -> [U8; 8] {
+    let (a0_0, c0_0) = u8_add(l[3], l[3]);
+    let (a0_1, c0_1) = u8_add(l[4], l[4]);
+    let (a0_2, c0_2) = u8_add(l[5], l[5]);
+    let (a0_3, c0_3) = u8_add(l[6], l[6]);
+    let (a0_4, c0_4) = u8_add(l[7], l[7]);
+    let (a0_5, c0_5) = u8_add(l[0], l[0]);
+    let (a0_6, c0_6) = u8_add(l[1], l[1]);
+    let (a0_7, c0_7) = u8_add(l[2], l[2]);
+    [u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6))]
+  }
+
+  fn rotl_43(l: [U8; 8]) -> [U8; 8] {
+    let (a0_0, c0_0) = u8_add(l[3], l[3]);
+    let (a0_1, c0_1) = u8_add(l[4], l[4]);
+    let (a0_2, c0_2) = u8_add(l[5], l[5]);
+    let (a0_3, c0_3) = u8_add(l[6], l[6]);
+    let (a0_4, c0_4) = u8_add(l[7], l[7]);
+    let (a0_5, c0_5) = u8_add(l[0], l[0]);
+    let (a0_6, c0_6) = u8_add(l[1], l[1]);
+    let (a0_7, c0_7) = u8_add(l[2], l[2]);
+    let (a1_0, c1_0) = u8_add(u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)));
+    let (a1_1, c1_1) = u8_add(u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)));
+    let (a1_2, c1_2) = u8_add(u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)));
+    let (a1_3, c1_3) = u8_add(u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)));
+    let (a1_4, c1_4) = u8_add(u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)));
+    let (a1_5, c1_5) = u8_add(u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)));
+    let (a1_6, c1_6) = u8_add(u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)));
+    let (a1_7, c1_7) = u8_add(u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)));
+    let (a2_0, c2_0) = u8_add(u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)), u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)));
+    let (a2_1, c2_1) = u8_add(u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)), u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)));
+    let (a2_2, c2_2) = u8_add(u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)), u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)));
+    let (a2_3, c2_3) = u8_add(u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)), u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)));
+    let (a2_4, c2_4) = u8_add(u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)), u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)));
+    let (a2_5, c2_5) = u8_add(u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)), u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)));
+    let (a2_6, c2_6) = u8_add(u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)), u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)));
+    let (a2_7, c2_7) = u8_add(u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6)), u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6)));
+    [u8_from_field_unsafe(to_field(a2_0) + to_field(c2_7)), u8_from_field_unsafe(to_field(a2_1) + to_field(c2_0)), u8_from_field_unsafe(to_field(a2_2) + to_field(c2_1)), u8_from_field_unsafe(to_field(a2_3) + to_field(c2_2)), u8_from_field_unsafe(to_field(a2_4) + to_field(c2_3)), u8_from_field_unsafe(to_field(a2_5) + to_field(c2_4)), u8_from_field_unsafe(to_field(a2_6) + to_field(c2_5)), u8_from_field_unsafe(to_field(a2_7) + to_field(c2_6))]
+  }
+
+  fn rotl_44(l: [U8; 8]) -> [U8; 8] {
+    let d0 = u8_bit_decomposition(l[0]);
+    let d1 = u8_bit_decomposition(l[1]);
+    let d2 = u8_bit_decomposition(l[2]);
+    let d3 = u8_bit_decomposition(l[3]);
+    let d4 = u8_bit_decomposition(l[4]);
+    let d5 = u8_bit_decomposition(l[5]);
+    let d6 = u8_bit_decomposition(l[6]);
+    let d7 = u8_bit_decomposition(l[7]);
+    [u8_from_field_unsafe(d2[4] + 2 * d2[5] + 4 * d2[6] + 8 * d2[7] + 16 * d3[0] + 32 * d3[1] + 64 * d3[2] + 128 * d3[3]), u8_from_field_unsafe(d3[4] + 2 * d3[5] + 4 * d3[6] + 8 * d3[7] + 16 * d4[0] + 32 * d4[1] + 64 * d4[2] + 128 * d4[3]), u8_from_field_unsafe(d4[4] + 2 * d4[5] + 4 * d4[6] + 8 * d4[7] + 16 * d5[0] + 32 * d5[1] + 64 * d5[2] + 128 * d5[3]), u8_from_field_unsafe(d5[4] + 2 * d5[5] + 4 * d5[6] + 8 * d5[7] + 16 * d6[0] + 32 * d6[1] + 64 * d6[2] + 128 * d6[3]), u8_from_field_unsafe(d6[4] + 2 * d6[5] + 4 * d6[6] + 8 * d6[7] + 16 * d7[0] + 32 * d7[1] + 64 * d7[2] + 128 * d7[3]), u8_from_field_unsafe(d7[4] + 2 * d7[5] + 4 * d7[6] + 8 * d7[7] + 16 * d0[0] + 32 * d0[1] + 64 * d0[2] + 128 * d0[3]), u8_from_field_unsafe(d0[4] + 2 * d0[5] + 4 * d0[6] + 8 * d0[7] + 16 * d1[0] + 32 * d1[1] + 64 * d1[2] + 128 * d1[3]), u8_from_field_unsafe(d1[4] + 2 * d1[5] + 4 * d1[6] + 8 * d1[7] + 16 * d2[0] + 32 * d2[1] + 64 * d2[2] + 128 * d2[3])]
+  }
+
+  fn rotl_45(l: [U8; 8]) -> [U8; 8] {
+    let h0_0 = u8_shift_right(l[2]);
+    let h0_1 = u8_shift_right(l[3]);
+    let h0_2 = u8_shift_right(l[4]);
+    let h0_3 = u8_shift_right(l[5]);
+    let h0_4 = u8_shift_right(l[6]);
+    let h0_5 = u8_shift_right(l[7]);
+    let h0_6 = u8_shift_right(l[0]);
+    let h0_7 = u8_shift_right(l[1]);
+    let h1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[3]) - 2 * to_field(h0_1))));
+    let h1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[4]) - 2 * to_field(h0_2))));
+    let h1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[5]) - 2 * to_field(h0_3))));
+    let h1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[6]) - 2 * to_field(h0_4))));
+    let h1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[7]) - 2 * to_field(h0_5))));
+    let h1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[0]) - 2 * to_field(h0_6))));
+    let h1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[1]) - 2 * to_field(h0_7))));
+    let h1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[2]) - 2 * to_field(h0_0))));
+    let h2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[4]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1))));
+    let h2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[5]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2))));
+    let h2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[6]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3))));
+    let h2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[7]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4))));
+    let h2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[0]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5))));
+    let h2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[1]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6))));
+    let h2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[2]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7))));
+    let h2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[3]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0))));
+    [u8_from_field_unsafe(to_field(h2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[5]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2)))) - 2 * to_field(h2_1))), u8_from_field_unsafe(to_field(h2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[6]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3)))) - 2 * to_field(h2_2))), u8_from_field_unsafe(to_field(h2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[7]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4)))) - 2 * to_field(h2_3))), u8_from_field_unsafe(to_field(h2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[0]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5)))) - 2 * to_field(h2_4))), u8_from_field_unsafe(to_field(h2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[1]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6)))) - 2 * to_field(h2_5))), u8_from_field_unsafe(to_field(h2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[2]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7)))) - 2 * to_field(h2_6))), u8_from_field_unsafe(to_field(h2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[3]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0)))) - 2 * to_field(h2_7))), u8_from_field_unsafe(to_field(h2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[4]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1)))) - 2 * to_field(h2_0)))]
+  }
+
+  fn rotl_55(l: [U8; 8]) -> [U8; 8] {
+    let h0_0 = u8_shift_right(l[1]);
+    let h0_1 = u8_shift_right(l[2]);
+    let h0_2 = u8_shift_right(l[3]);
+    let h0_3 = u8_shift_right(l[4]);
+    let h0_4 = u8_shift_right(l[5]);
+    let h0_5 = u8_shift_right(l[6]);
+    let h0_6 = u8_shift_right(l[7]);
+    let h0_7 = u8_shift_right(l[0]);
+    [u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[2]) - 2 * to_field(h0_1))), u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[3]) - 2 * to_field(h0_2))), u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[4]) - 2 * to_field(h0_3))), u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[5]) - 2 * to_field(h0_4))), u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[6]) - 2 * to_field(h0_5))), u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[7]) - 2 * to_field(h0_6))), u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[0]) - 2 * to_field(h0_7))), u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[1]) - 2 * to_field(h0_0)))]
+  }
+
+  fn rotl_56(l: [U8; 8]) -> [U8; 8] {
+    [l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[0]]
+  }
+
+  fn rotl_61(l: [U8; 8]) -> [U8; 8] {
+    let h0_0 = u8_shift_right(l[0]);
+    let h0_1 = u8_shift_right(l[1]);
+    let h0_2 = u8_shift_right(l[2]);
+    let h0_3 = u8_shift_right(l[3]);
+    let h0_4 = u8_shift_right(l[4]);
+    let h0_5 = u8_shift_right(l[5]);
+    let h0_6 = u8_shift_right(l[6]);
+    let h0_7 = u8_shift_right(l[7]);
+    let h1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[1]) - 2 * to_field(h0_1))));
+    let h1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[2]) - 2 * to_field(h0_2))));
+    let h1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[3]) - 2 * to_field(h0_3))));
+    let h1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[4]) - 2 * to_field(h0_4))));
+    let h1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[5]) - 2 * to_field(h0_5))));
+    let h1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[6]) - 2 * to_field(h0_6))));
+    let h1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[7]) - 2 * to_field(h0_7))));
+    let h1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[0]) - 2 * to_field(h0_0))));
+    let h2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[2]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1))));
+    let h2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[3]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2))));
+    let h2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[4]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3))));
+    let h2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[5]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4))));
+    let h2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[6]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5))));
+    let h2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[7]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6))));
+    let h2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[0]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7))));
+    let h2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[1]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0))));
+    [u8_from_field_unsafe(to_field(h2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[3]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2)))) - 2 * to_field(h2_1))), u8_from_field_unsafe(to_field(h2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[4]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3)))) - 2 * to_field(h2_2))), u8_from_field_unsafe(to_field(h2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[5]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4)))) - 2 * to_field(h2_3))), u8_from_field_unsafe(to_field(h2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[6]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5)))) - 2 * to_field(h2_4))), u8_from_field_unsafe(to_field(h2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[7]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6)))) - 2 * to_field(h2_5))), u8_from_field_unsafe(to_field(h2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[0]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7)))) - 2 * to_field(h2_6))), u8_from_field_unsafe(to_field(h2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[1]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0)))) - 2 * to_field(h2_7))), u8_from_field_unsafe(to_field(h2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[2]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1)))) - 2 * to_field(h2_0)))]
+  }
+
+  fn rotl_62(l: [U8; 8]) -> [U8; 8] {
+    let h0_0 = u8_shift_right(l[0]);
+    let h0_1 = u8_shift_right(l[1]);
+    let h0_2 = u8_shift_right(l[2]);
+    let h0_3 = u8_shift_right(l[3]);
+    let h0_4 = u8_shift_right(l[4]);
+    let h0_5 = u8_shift_right(l[5]);
+    let h0_6 = u8_shift_right(l[6]);
+    let h0_7 = u8_shift_right(l[7]);
+    let h1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[1]) - 2 * to_field(h0_1))));
+    let h1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[2]) - 2 * to_field(h0_2))));
+    let h1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[3]) - 2 * to_field(h0_3))));
+    let h1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[4]) - 2 * to_field(h0_4))));
+    let h1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[5]) - 2 * to_field(h0_5))));
+    let h1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[6]) - 2 * to_field(h0_6))));
+    let h1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[7]) - 2 * to_field(h0_7))));
+    let h1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[0]) - 2 * to_field(h0_0))));
+    [u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[2]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1))), u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[3]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2))), u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[4]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3))), u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[5]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4))), u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[6]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5))), u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[7]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6))), u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[0]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7))), u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[1]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0)))]
+  }
+
+  /- # keccak-f[1600]: 24 rounds, each an inlined `@keccak_round` so all
+     24 share one circuit (one row per permutation). -/
 
   fn keccak_f(s: [[U8; 8]; 25]) -> [[U8; 8]; 25] {
     let s = @keccak_round(s, [0x01u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
@@ -168,489 +620,98 @@ def keccak := ⟦
     @keccak_round(s, [0x08u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8])
   }
 
-  fn keccak_round(s0: [[U8; 8]; 25], rc0: [U8; 8]) -> [[U8; 8]; 25] {
-      -- round 0: theta
-      let c0_0 = [u8_xor(s0[20][0], u8_xor(s0[15][0], u8_xor(s0[10][0], u8_xor(s0[5][0], s0[0][0])))), u8_xor(s0[20][1], u8_xor(s0[15][1], u8_xor(s0[10][1], u8_xor(s0[5][1], s0[0][1])))), u8_xor(s0[20][2], u8_xor(s0[15][2], u8_xor(s0[10][2], u8_xor(s0[5][2], s0[0][2])))), u8_xor(s0[20][3], u8_xor(s0[15][3], u8_xor(s0[10][3], u8_xor(s0[5][3], s0[0][3])))), u8_xor(s0[20][4], u8_xor(s0[15][4], u8_xor(s0[10][4], u8_xor(s0[5][4], s0[0][4])))), u8_xor(s0[20][5], u8_xor(s0[15][5], u8_xor(s0[10][5], u8_xor(s0[5][5], s0[0][5])))), u8_xor(s0[20][6], u8_xor(s0[15][6], u8_xor(s0[10][6], u8_xor(s0[5][6], s0[0][6])))), u8_xor(s0[20][7], u8_xor(s0[15][7], u8_xor(s0[10][7], u8_xor(s0[5][7], s0[0][7]))))];
-      let c1_0 = [u8_xor(s0[21][0], u8_xor(s0[16][0], u8_xor(s0[11][0], u8_xor(s0[6][0], s0[1][0])))), u8_xor(s0[21][1], u8_xor(s0[16][1], u8_xor(s0[11][1], u8_xor(s0[6][1], s0[1][1])))), u8_xor(s0[21][2], u8_xor(s0[16][2], u8_xor(s0[11][2], u8_xor(s0[6][2], s0[1][2])))), u8_xor(s0[21][3], u8_xor(s0[16][3], u8_xor(s0[11][3], u8_xor(s0[6][3], s0[1][3])))), u8_xor(s0[21][4], u8_xor(s0[16][4], u8_xor(s0[11][4], u8_xor(s0[6][4], s0[1][4])))), u8_xor(s0[21][5], u8_xor(s0[16][5], u8_xor(s0[11][5], u8_xor(s0[6][5], s0[1][5])))), u8_xor(s0[21][6], u8_xor(s0[16][6], u8_xor(s0[11][6], u8_xor(s0[6][6], s0[1][6])))), u8_xor(s0[21][7], u8_xor(s0[16][7], u8_xor(s0[11][7], u8_xor(s0[6][7], s0[1][7]))))];
-      let c2_0 = [u8_xor(s0[22][0], u8_xor(s0[17][0], u8_xor(s0[12][0], u8_xor(s0[7][0], s0[2][0])))), u8_xor(s0[22][1], u8_xor(s0[17][1], u8_xor(s0[12][1], u8_xor(s0[7][1], s0[2][1])))), u8_xor(s0[22][2], u8_xor(s0[17][2], u8_xor(s0[12][2], u8_xor(s0[7][2], s0[2][2])))), u8_xor(s0[22][3], u8_xor(s0[17][3], u8_xor(s0[12][3], u8_xor(s0[7][3], s0[2][3])))), u8_xor(s0[22][4], u8_xor(s0[17][4], u8_xor(s0[12][4], u8_xor(s0[7][4], s0[2][4])))), u8_xor(s0[22][5], u8_xor(s0[17][5], u8_xor(s0[12][5], u8_xor(s0[7][5], s0[2][5])))), u8_xor(s0[22][6], u8_xor(s0[17][6], u8_xor(s0[12][6], u8_xor(s0[7][6], s0[2][6])))), u8_xor(s0[22][7], u8_xor(s0[17][7], u8_xor(s0[12][7], u8_xor(s0[7][7], s0[2][7]))))];
-      let c3_0 = [u8_xor(s0[23][0], u8_xor(s0[18][0], u8_xor(s0[13][0], u8_xor(s0[8][0], s0[3][0])))), u8_xor(s0[23][1], u8_xor(s0[18][1], u8_xor(s0[13][1], u8_xor(s0[8][1], s0[3][1])))), u8_xor(s0[23][2], u8_xor(s0[18][2], u8_xor(s0[13][2], u8_xor(s0[8][2], s0[3][2])))), u8_xor(s0[23][3], u8_xor(s0[18][3], u8_xor(s0[13][3], u8_xor(s0[8][3], s0[3][3])))), u8_xor(s0[23][4], u8_xor(s0[18][4], u8_xor(s0[13][4], u8_xor(s0[8][4], s0[3][4])))), u8_xor(s0[23][5], u8_xor(s0[18][5], u8_xor(s0[13][5], u8_xor(s0[8][5], s0[3][5])))), u8_xor(s0[23][6], u8_xor(s0[18][6], u8_xor(s0[13][6], u8_xor(s0[8][6], s0[3][6])))), u8_xor(s0[23][7], u8_xor(s0[18][7], u8_xor(s0[13][7], u8_xor(s0[8][7], s0[3][7]))))];
-      let c4_0 = [u8_xor(s0[24][0], u8_xor(s0[19][0], u8_xor(s0[14][0], u8_xor(s0[9][0], s0[4][0])))), u8_xor(s0[24][1], u8_xor(s0[19][1], u8_xor(s0[14][1], u8_xor(s0[9][1], s0[4][1])))), u8_xor(s0[24][2], u8_xor(s0[19][2], u8_xor(s0[14][2], u8_xor(s0[9][2], s0[4][2])))), u8_xor(s0[24][3], u8_xor(s0[19][3], u8_xor(s0[14][3], u8_xor(s0[9][3], s0[4][3])))), u8_xor(s0[24][4], u8_xor(s0[19][4], u8_xor(s0[14][4], u8_xor(s0[9][4], s0[4][4])))), u8_xor(s0[24][5], u8_xor(s0[19][5], u8_xor(s0[14][5], u8_xor(s0[9][5], s0[4][5])))), u8_xor(s0[24][6], u8_xor(s0[19][6], u8_xor(s0[14][6], u8_xor(s0[9][6], s0[4][6])))), u8_xor(s0[24][7], u8_xor(s0[19][7], u8_xor(s0[14][7], u8_xor(s0[9][7], s0[4][7]))))];
-      let (l0_0_0, m0_0_0) = u8_add(c0_0[0], c0_0[0]);
-      let (l0_0_1, m0_0_1) = u8_add(c0_0[1], c0_0[1]);
-      let (l0_0_2, m0_0_2) = u8_add(c0_0[2], c0_0[2]);
-      let (l0_0_3, m0_0_3) = u8_add(c0_0[3], c0_0[3]);
-      let (l0_0_4, m0_0_4) = u8_add(c0_0[4], c0_0[4]);
-      let (l0_0_5, m0_0_5) = u8_add(c0_0[5], c0_0[5]);
-      let (l0_0_6, m0_0_6) = u8_add(c0_0[6], c0_0[6]);
-      let (l0_0_7, m0_0_7) = u8_add(c0_0[7], c0_0[7]);
-      let r0_0 = [u8_from_field_unsafe(to_field(l0_0_0) + to_field(m0_0_7)), u8_from_field_unsafe(to_field(l0_0_1) + to_field(m0_0_0)), u8_from_field_unsafe(to_field(l0_0_2) + to_field(m0_0_1)), u8_from_field_unsafe(to_field(l0_0_3) + to_field(m0_0_2)), u8_from_field_unsafe(to_field(l0_0_4) + to_field(m0_0_3)), u8_from_field_unsafe(to_field(l0_0_5) + to_field(m0_0_4)), u8_from_field_unsafe(to_field(l0_0_6) + to_field(m0_0_5)), u8_from_field_unsafe(to_field(l0_0_7) + to_field(m0_0_6))];
-      let (l1_0_0, m1_0_0) = u8_add(c1_0[0], c1_0[0]);
-      let (l1_0_1, m1_0_1) = u8_add(c1_0[1], c1_0[1]);
-      let (l1_0_2, m1_0_2) = u8_add(c1_0[2], c1_0[2]);
-      let (l1_0_3, m1_0_3) = u8_add(c1_0[3], c1_0[3]);
-      let (l1_0_4, m1_0_4) = u8_add(c1_0[4], c1_0[4]);
-      let (l1_0_5, m1_0_5) = u8_add(c1_0[5], c1_0[5]);
-      let (l1_0_6, m1_0_6) = u8_add(c1_0[6], c1_0[6]);
-      let (l1_0_7, m1_0_7) = u8_add(c1_0[7], c1_0[7]);
-      let r1_0 = [u8_from_field_unsafe(to_field(l1_0_0) + to_field(m1_0_7)), u8_from_field_unsafe(to_field(l1_0_1) + to_field(m1_0_0)), u8_from_field_unsafe(to_field(l1_0_2) + to_field(m1_0_1)), u8_from_field_unsafe(to_field(l1_0_3) + to_field(m1_0_2)), u8_from_field_unsafe(to_field(l1_0_4) + to_field(m1_0_3)), u8_from_field_unsafe(to_field(l1_0_5) + to_field(m1_0_4)), u8_from_field_unsafe(to_field(l1_0_6) + to_field(m1_0_5)), u8_from_field_unsafe(to_field(l1_0_7) + to_field(m1_0_6))];
-      let (l2_0_0, m2_0_0) = u8_add(c2_0[0], c2_0[0]);
-      let (l2_0_1, m2_0_1) = u8_add(c2_0[1], c2_0[1]);
-      let (l2_0_2, m2_0_2) = u8_add(c2_0[2], c2_0[2]);
-      let (l2_0_3, m2_0_3) = u8_add(c2_0[3], c2_0[3]);
-      let (l2_0_4, m2_0_4) = u8_add(c2_0[4], c2_0[4]);
-      let (l2_0_5, m2_0_5) = u8_add(c2_0[5], c2_0[5]);
-      let (l2_0_6, m2_0_6) = u8_add(c2_0[6], c2_0[6]);
-      let (l2_0_7, m2_0_7) = u8_add(c2_0[7], c2_0[7]);
-      let r2_0 = [u8_from_field_unsafe(to_field(l2_0_0) + to_field(m2_0_7)), u8_from_field_unsafe(to_field(l2_0_1) + to_field(m2_0_0)), u8_from_field_unsafe(to_field(l2_0_2) + to_field(m2_0_1)), u8_from_field_unsafe(to_field(l2_0_3) + to_field(m2_0_2)), u8_from_field_unsafe(to_field(l2_0_4) + to_field(m2_0_3)), u8_from_field_unsafe(to_field(l2_0_5) + to_field(m2_0_4)), u8_from_field_unsafe(to_field(l2_0_6) + to_field(m2_0_5)), u8_from_field_unsafe(to_field(l2_0_7) + to_field(m2_0_6))];
-      let (l3_0_0, m3_0_0) = u8_add(c3_0[0], c3_0[0]);
-      let (l3_0_1, m3_0_1) = u8_add(c3_0[1], c3_0[1]);
-      let (l3_0_2, m3_0_2) = u8_add(c3_0[2], c3_0[2]);
-      let (l3_0_3, m3_0_3) = u8_add(c3_0[3], c3_0[3]);
-      let (l3_0_4, m3_0_4) = u8_add(c3_0[4], c3_0[4]);
-      let (l3_0_5, m3_0_5) = u8_add(c3_0[5], c3_0[5]);
-      let (l3_0_6, m3_0_6) = u8_add(c3_0[6], c3_0[6]);
-      let (l3_0_7, m3_0_7) = u8_add(c3_0[7], c3_0[7]);
-      let r3_0 = [u8_from_field_unsafe(to_field(l3_0_0) + to_field(m3_0_7)), u8_from_field_unsafe(to_field(l3_0_1) + to_field(m3_0_0)), u8_from_field_unsafe(to_field(l3_0_2) + to_field(m3_0_1)), u8_from_field_unsafe(to_field(l3_0_3) + to_field(m3_0_2)), u8_from_field_unsafe(to_field(l3_0_4) + to_field(m3_0_3)), u8_from_field_unsafe(to_field(l3_0_5) + to_field(m3_0_4)), u8_from_field_unsafe(to_field(l3_0_6) + to_field(m3_0_5)), u8_from_field_unsafe(to_field(l3_0_7) + to_field(m3_0_6))];
-      let (l4_0_0, m4_0_0) = u8_add(c4_0[0], c4_0[0]);
-      let (l4_0_1, m4_0_1) = u8_add(c4_0[1], c4_0[1]);
-      let (l4_0_2, m4_0_2) = u8_add(c4_0[2], c4_0[2]);
-      let (l4_0_3, m4_0_3) = u8_add(c4_0[3], c4_0[3]);
-      let (l4_0_4, m4_0_4) = u8_add(c4_0[4], c4_0[4]);
-      let (l4_0_5, m4_0_5) = u8_add(c4_0[5], c4_0[5]);
-      let (l4_0_6, m4_0_6) = u8_add(c4_0[6], c4_0[6]);
-      let (l4_0_7, m4_0_7) = u8_add(c4_0[7], c4_0[7]);
-      let r4_0 = [u8_from_field_unsafe(to_field(l4_0_0) + to_field(m4_0_7)), u8_from_field_unsafe(to_field(l4_0_1) + to_field(m4_0_0)), u8_from_field_unsafe(to_field(l4_0_2) + to_field(m4_0_1)), u8_from_field_unsafe(to_field(l4_0_3) + to_field(m4_0_2)), u8_from_field_unsafe(to_field(l4_0_4) + to_field(m4_0_3)), u8_from_field_unsafe(to_field(l4_0_5) + to_field(m4_0_4)), u8_from_field_unsafe(to_field(l4_0_6) + to_field(m4_0_5)), u8_from_field_unsafe(to_field(l4_0_7) + to_field(m4_0_6))];
-      let dd0_0 = [u8_xor(c4_0[0], r1_0[0]), u8_xor(c4_0[1], r1_0[1]), u8_xor(c4_0[2], r1_0[2]), u8_xor(c4_0[3], r1_0[3]), u8_xor(c4_0[4], r1_0[4]), u8_xor(c4_0[5], r1_0[5]), u8_xor(c4_0[6], r1_0[6]), u8_xor(c4_0[7], r1_0[7])];
-      let dd1_0 = [u8_xor(c0_0[0], r2_0[0]), u8_xor(c0_0[1], r2_0[1]), u8_xor(c0_0[2], r2_0[2]), u8_xor(c0_0[3], r2_0[3]), u8_xor(c0_0[4], r2_0[4]), u8_xor(c0_0[5], r2_0[5]), u8_xor(c0_0[6], r2_0[6]), u8_xor(c0_0[7], r2_0[7])];
-      let dd2_0 = [u8_xor(c1_0[0], r3_0[0]), u8_xor(c1_0[1], r3_0[1]), u8_xor(c1_0[2], r3_0[2]), u8_xor(c1_0[3], r3_0[3]), u8_xor(c1_0[4], r3_0[4]), u8_xor(c1_0[5], r3_0[5]), u8_xor(c1_0[6], r3_0[6]), u8_xor(c1_0[7], r3_0[7])];
-      let dd3_0 = [u8_xor(c2_0[0], r4_0[0]), u8_xor(c2_0[1], r4_0[1]), u8_xor(c2_0[2], r4_0[2]), u8_xor(c2_0[3], r4_0[3]), u8_xor(c2_0[4], r4_0[4]), u8_xor(c2_0[5], r4_0[5]), u8_xor(c2_0[6], r4_0[6]), u8_xor(c2_0[7], r4_0[7])];
-      let dd4_0 = [u8_xor(c3_0[0], r0_0[0]), u8_xor(c3_0[1], r0_0[1]), u8_xor(c3_0[2], r0_0[2]), u8_xor(c3_0[3], r0_0[3]), u8_xor(c3_0[4], r0_0[4]), u8_xor(c3_0[5], r0_0[5]), u8_xor(c3_0[6], r0_0[6]), u8_xor(c3_0[7], r0_0[7])];
-      let t0_0 = [u8_xor(s0[0][0], dd0_0[0]), u8_xor(s0[0][1], dd0_0[1]), u8_xor(s0[0][2], dd0_0[2]), u8_xor(s0[0][3], dd0_0[3]), u8_xor(s0[0][4], dd0_0[4]), u8_xor(s0[0][5], dd0_0[5]), u8_xor(s0[0][6], dd0_0[6]), u8_xor(s0[0][7], dd0_0[7])];
-      let t1_0 = [u8_xor(s0[1][0], dd1_0[0]), u8_xor(s0[1][1], dd1_0[1]), u8_xor(s0[1][2], dd1_0[2]), u8_xor(s0[1][3], dd1_0[3]), u8_xor(s0[1][4], dd1_0[4]), u8_xor(s0[1][5], dd1_0[5]), u8_xor(s0[1][6], dd1_0[6]), u8_xor(s0[1][7], dd1_0[7])];
-      let t2_0 = [u8_xor(s0[2][0], dd2_0[0]), u8_xor(s0[2][1], dd2_0[1]), u8_xor(s0[2][2], dd2_0[2]), u8_xor(s0[2][3], dd2_0[3]), u8_xor(s0[2][4], dd2_0[4]), u8_xor(s0[2][5], dd2_0[5]), u8_xor(s0[2][6], dd2_0[6]), u8_xor(s0[2][7], dd2_0[7])];
-      let t3_0 = [u8_xor(s0[3][0], dd3_0[0]), u8_xor(s0[3][1], dd3_0[1]), u8_xor(s0[3][2], dd3_0[2]), u8_xor(s0[3][3], dd3_0[3]), u8_xor(s0[3][4], dd3_0[4]), u8_xor(s0[3][5], dd3_0[5]), u8_xor(s0[3][6], dd3_0[6]), u8_xor(s0[3][7], dd3_0[7])];
-      let t4_0 = [u8_xor(s0[4][0], dd4_0[0]), u8_xor(s0[4][1], dd4_0[1]), u8_xor(s0[4][2], dd4_0[2]), u8_xor(s0[4][3], dd4_0[3]), u8_xor(s0[4][4], dd4_0[4]), u8_xor(s0[4][5], dd4_0[5]), u8_xor(s0[4][6], dd4_0[6]), u8_xor(s0[4][7], dd4_0[7])];
-      let t5_0 = [u8_xor(s0[5][0], dd0_0[0]), u8_xor(s0[5][1], dd0_0[1]), u8_xor(s0[5][2], dd0_0[2]), u8_xor(s0[5][3], dd0_0[3]), u8_xor(s0[5][4], dd0_0[4]), u8_xor(s0[5][5], dd0_0[5]), u8_xor(s0[5][6], dd0_0[6]), u8_xor(s0[5][7], dd0_0[7])];
-      let t6_0 = [u8_xor(s0[6][0], dd1_0[0]), u8_xor(s0[6][1], dd1_0[1]), u8_xor(s0[6][2], dd1_0[2]), u8_xor(s0[6][3], dd1_0[3]), u8_xor(s0[6][4], dd1_0[4]), u8_xor(s0[6][5], dd1_0[5]), u8_xor(s0[6][6], dd1_0[6]), u8_xor(s0[6][7], dd1_0[7])];
-      let t7_0 = [u8_xor(s0[7][0], dd2_0[0]), u8_xor(s0[7][1], dd2_0[1]), u8_xor(s0[7][2], dd2_0[2]), u8_xor(s0[7][3], dd2_0[3]), u8_xor(s0[7][4], dd2_0[4]), u8_xor(s0[7][5], dd2_0[5]), u8_xor(s0[7][6], dd2_0[6]), u8_xor(s0[7][7], dd2_0[7])];
-      let t8_0 = [u8_xor(s0[8][0], dd3_0[0]), u8_xor(s0[8][1], dd3_0[1]), u8_xor(s0[8][2], dd3_0[2]), u8_xor(s0[8][3], dd3_0[3]), u8_xor(s0[8][4], dd3_0[4]), u8_xor(s0[8][5], dd3_0[5]), u8_xor(s0[8][6], dd3_0[6]), u8_xor(s0[8][7], dd3_0[7])];
-      let t9_0 = [u8_xor(s0[9][0], dd4_0[0]), u8_xor(s0[9][1], dd4_0[1]), u8_xor(s0[9][2], dd4_0[2]), u8_xor(s0[9][3], dd4_0[3]), u8_xor(s0[9][4], dd4_0[4]), u8_xor(s0[9][5], dd4_0[5]), u8_xor(s0[9][6], dd4_0[6]), u8_xor(s0[9][7], dd4_0[7])];
-      let t10_0 = [u8_xor(s0[10][0], dd0_0[0]), u8_xor(s0[10][1], dd0_0[1]), u8_xor(s0[10][2], dd0_0[2]), u8_xor(s0[10][3], dd0_0[3]), u8_xor(s0[10][4], dd0_0[4]), u8_xor(s0[10][5], dd0_0[5]), u8_xor(s0[10][6], dd0_0[6]), u8_xor(s0[10][7], dd0_0[7])];
-      let t11_0 = [u8_xor(s0[11][0], dd1_0[0]), u8_xor(s0[11][1], dd1_0[1]), u8_xor(s0[11][2], dd1_0[2]), u8_xor(s0[11][3], dd1_0[3]), u8_xor(s0[11][4], dd1_0[4]), u8_xor(s0[11][5], dd1_0[5]), u8_xor(s0[11][6], dd1_0[6]), u8_xor(s0[11][7], dd1_0[7])];
-      let t12_0 = [u8_xor(s0[12][0], dd2_0[0]), u8_xor(s0[12][1], dd2_0[1]), u8_xor(s0[12][2], dd2_0[2]), u8_xor(s0[12][3], dd2_0[3]), u8_xor(s0[12][4], dd2_0[4]), u8_xor(s0[12][5], dd2_0[5]), u8_xor(s0[12][6], dd2_0[6]), u8_xor(s0[12][7], dd2_0[7])];
-      let t13_0 = [u8_xor(s0[13][0], dd3_0[0]), u8_xor(s0[13][1], dd3_0[1]), u8_xor(s0[13][2], dd3_0[2]), u8_xor(s0[13][3], dd3_0[3]), u8_xor(s0[13][4], dd3_0[4]), u8_xor(s0[13][5], dd3_0[5]), u8_xor(s0[13][6], dd3_0[6]), u8_xor(s0[13][7], dd3_0[7])];
-      let t14_0 = [u8_xor(s0[14][0], dd4_0[0]), u8_xor(s0[14][1], dd4_0[1]), u8_xor(s0[14][2], dd4_0[2]), u8_xor(s0[14][3], dd4_0[3]), u8_xor(s0[14][4], dd4_0[4]), u8_xor(s0[14][5], dd4_0[5]), u8_xor(s0[14][6], dd4_0[6]), u8_xor(s0[14][7], dd4_0[7])];
-      let t15_0 = [u8_xor(s0[15][0], dd0_0[0]), u8_xor(s0[15][1], dd0_0[1]), u8_xor(s0[15][2], dd0_0[2]), u8_xor(s0[15][3], dd0_0[3]), u8_xor(s0[15][4], dd0_0[4]), u8_xor(s0[15][5], dd0_0[5]), u8_xor(s0[15][6], dd0_0[6]), u8_xor(s0[15][7], dd0_0[7])];
-      let t16_0 = [u8_xor(s0[16][0], dd1_0[0]), u8_xor(s0[16][1], dd1_0[1]), u8_xor(s0[16][2], dd1_0[2]), u8_xor(s0[16][3], dd1_0[3]), u8_xor(s0[16][4], dd1_0[4]), u8_xor(s0[16][5], dd1_0[5]), u8_xor(s0[16][6], dd1_0[6]), u8_xor(s0[16][7], dd1_0[7])];
-      let t17_0 = [u8_xor(s0[17][0], dd2_0[0]), u8_xor(s0[17][1], dd2_0[1]), u8_xor(s0[17][2], dd2_0[2]), u8_xor(s0[17][3], dd2_0[3]), u8_xor(s0[17][4], dd2_0[4]), u8_xor(s0[17][5], dd2_0[5]), u8_xor(s0[17][6], dd2_0[6]), u8_xor(s0[17][7], dd2_0[7])];
-      let t18_0 = [u8_xor(s0[18][0], dd3_0[0]), u8_xor(s0[18][1], dd3_0[1]), u8_xor(s0[18][2], dd3_0[2]), u8_xor(s0[18][3], dd3_0[3]), u8_xor(s0[18][4], dd3_0[4]), u8_xor(s0[18][5], dd3_0[5]), u8_xor(s0[18][6], dd3_0[6]), u8_xor(s0[18][7], dd3_0[7])];
-      let t19_0 = [u8_xor(s0[19][0], dd4_0[0]), u8_xor(s0[19][1], dd4_0[1]), u8_xor(s0[19][2], dd4_0[2]), u8_xor(s0[19][3], dd4_0[3]), u8_xor(s0[19][4], dd4_0[4]), u8_xor(s0[19][5], dd4_0[5]), u8_xor(s0[19][6], dd4_0[6]), u8_xor(s0[19][7], dd4_0[7])];
-      let t20_0 = [u8_xor(s0[20][0], dd0_0[0]), u8_xor(s0[20][1], dd0_0[1]), u8_xor(s0[20][2], dd0_0[2]), u8_xor(s0[20][3], dd0_0[3]), u8_xor(s0[20][4], dd0_0[4]), u8_xor(s0[20][5], dd0_0[5]), u8_xor(s0[20][6], dd0_0[6]), u8_xor(s0[20][7], dd0_0[7])];
-      let t21_0 = [u8_xor(s0[21][0], dd1_0[0]), u8_xor(s0[21][1], dd1_0[1]), u8_xor(s0[21][2], dd1_0[2]), u8_xor(s0[21][3], dd1_0[3]), u8_xor(s0[21][4], dd1_0[4]), u8_xor(s0[21][5], dd1_0[5]), u8_xor(s0[21][6], dd1_0[6]), u8_xor(s0[21][7], dd1_0[7])];
-      let t22_0 = [u8_xor(s0[22][0], dd2_0[0]), u8_xor(s0[22][1], dd2_0[1]), u8_xor(s0[22][2], dd2_0[2]), u8_xor(s0[22][3], dd2_0[3]), u8_xor(s0[22][4], dd2_0[4]), u8_xor(s0[22][5], dd2_0[5]), u8_xor(s0[22][6], dd2_0[6]), u8_xor(s0[22][7], dd2_0[7])];
-      let t23_0 = [u8_xor(s0[23][0], dd3_0[0]), u8_xor(s0[23][1], dd3_0[1]), u8_xor(s0[23][2], dd3_0[2]), u8_xor(s0[23][3], dd3_0[3]), u8_xor(s0[23][4], dd3_0[4]), u8_xor(s0[23][5], dd3_0[5]), u8_xor(s0[23][6], dd3_0[6]), u8_xor(s0[23][7], dd3_0[7])];
-      let t24_0 = [u8_xor(s0[24][0], dd4_0[0]), u8_xor(s0[24][1], dd4_0[1]), u8_xor(s0[24][2], dd4_0[2]), u8_xor(s0[24][3], dd4_0[3]), u8_xor(s0[24][4], dd4_0[4]), u8_xor(s0[24][5], dd4_0[5]), u8_xor(s0[24][6], dd4_0[6]), u8_xor(s0[24][7], dd4_0[7])];
-      -- round 0: rho + pi
-      -- b0_0 = rotl(t0, 0): byte rotation only (free)
-      let b0_0 = [t0_0[0], t0_0[1], t0_0[2], t0_0[3], t0_0[4], t0_0[5], t0_0[6], t0_0[7]];
-      -- b10_0 = rotl(t1, 1) = byte-rotl 0 + 1x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a10_0_0_0, c10_0_0_0) = u8_add(t1_0[0], t1_0[0]);
-      let (a10_0_0_1, c10_0_0_1) = u8_add(t1_0[1], t1_0[1]);
-      let (a10_0_0_2, c10_0_0_2) = u8_add(t1_0[2], t1_0[2]);
-      let (a10_0_0_3, c10_0_0_3) = u8_add(t1_0[3], t1_0[3]);
-      let (a10_0_0_4, c10_0_0_4) = u8_add(t1_0[4], t1_0[4]);
-      let (a10_0_0_5, c10_0_0_5) = u8_add(t1_0[5], t1_0[5]);
-      let (a10_0_0_6, c10_0_0_6) = u8_add(t1_0[6], t1_0[6]);
-      let (a10_0_0_7, c10_0_0_7) = u8_add(t1_0[7], t1_0[7]);
-      let b10_0 = [u8_from_field_unsafe(to_field(a10_0_0_0) + to_field(c10_0_0_7)), u8_from_field_unsafe(to_field(a10_0_0_1) + to_field(c10_0_0_0)), u8_from_field_unsafe(to_field(a10_0_0_2) + to_field(c10_0_0_1)), u8_from_field_unsafe(to_field(a10_0_0_3) + to_field(c10_0_0_2)), u8_from_field_unsafe(to_field(a10_0_0_4) + to_field(c10_0_0_3)), u8_from_field_unsafe(to_field(a10_0_0_5) + to_field(c10_0_0_4)), u8_from_field_unsafe(to_field(a10_0_0_6) + to_field(c10_0_0_5)), u8_from_field_unsafe(to_field(a10_0_0_7) + to_field(c10_0_0_6))];
-      -- b20_0 = rotl(t2, 62) = byte-rotl 8 + 2x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h20_0_0_0 = u8_shift_right(t2_0[0]);
-      let h20_0_0_1 = u8_shift_right(t2_0[1]);
-      let h20_0_0_2 = u8_shift_right(t2_0[2]);
-      let h20_0_0_3 = u8_shift_right(t2_0[3]);
-      let h20_0_0_4 = u8_shift_right(t2_0[4]);
-      let h20_0_0_5 = u8_shift_right(t2_0[5]);
-      let h20_0_0_6 = u8_shift_right(t2_0[6]);
-      let h20_0_0_7 = u8_shift_right(t2_0[7]);
-      let h20_0_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_0) + 128 * (to_field(t2_0[1]) - 2 * to_field(h20_0_0_1))));
-      let h20_0_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_1) + 128 * (to_field(t2_0[2]) - 2 * to_field(h20_0_0_2))));
-      let h20_0_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_2) + 128 * (to_field(t2_0[3]) - 2 * to_field(h20_0_0_3))));
-      let h20_0_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_3) + 128 * (to_field(t2_0[4]) - 2 * to_field(h20_0_0_4))));
-      let h20_0_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_4) + 128 * (to_field(t2_0[5]) - 2 * to_field(h20_0_0_5))));
-      let h20_0_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_5) + 128 * (to_field(t2_0[6]) - 2 * to_field(h20_0_0_6))));
-      let h20_0_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_6) + 128 * (to_field(t2_0[7]) - 2 * to_field(h20_0_0_7))));
-      let h20_0_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h20_0_0_7) + 128 * (to_field(t2_0[0]) - 2 * to_field(h20_0_0_0))));
-      let b20_0 = [u8_from_field_unsafe(to_field(h20_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_1) + 128 * (to_field(t2_0[2]) - 2 * to_field(h20_0_0_2)))) - 2 * to_field(h20_0_1_1))), u8_from_field_unsafe(to_field(h20_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_2) + 128 * (to_field(t2_0[3]) - 2 * to_field(h20_0_0_3)))) - 2 * to_field(h20_0_1_2))), u8_from_field_unsafe(to_field(h20_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_3) + 128 * (to_field(t2_0[4]) - 2 * to_field(h20_0_0_4)))) - 2 * to_field(h20_0_1_3))), u8_from_field_unsafe(to_field(h20_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_4) + 128 * (to_field(t2_0[5]) - 2 * to_field(h20_0_0_5)))) - 2 * to_field(h20_0_1_4))), u8_from_field_unsafe(to_field(h20_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_5) + 128 * (to_field(t2_0[6]) - 2 * to_field(h20_0_0_6)))) - 2 * to_field(h20_0_1_5))), u8_from_field_unsafe(to_field(h20_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_6) + 128 * (to_field(t2_0[7]) - 2 * to_field(h20_0_0_7)))) - 2 * to_field(h20_0_1_6))), u8_from_field_unsafe(to_field(h20_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_7) + 128 * (to_field(t2_0[0]) - 2 * to_field(h20_0_0_0)))) - 2 * to_field(h20_0_1_7))), u8_from_field_unsafe(to_field(h20_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h20_0_0_0) + 128 * (to_field(t2_0[1]) - 2 * to_field(h20_0_0_1)))) - 2 * to_field(h20_0_1_0)))];
-      -- b5_0 = rotl(t3, 28) = byte-rotl 3 + bit-shl 4 (decomposition)
-      let d5_0_0 = u8_bit_decomposition(t3_0[0]);
-      let d5_0_1 = u8_bit_decomposition(t3_0[1]);
-      let d5_0_2 = u8_bit_decomposition(t3_0[2]);
-      let d5_0_3 = u8_bit_decomposition(t3_0[3]);
-      let d5_0_4 = u8_bit_decomposition(t3_0[4]);
-      let d5_0_5 = u8_bit_decomposition(t3_0[5]);
-      let d5_0_6 = u8_bit_decomposition(t3_0[6]);
-      let d5_0_7 = u8_bit_decomposition(t3_0[7]);
-      let b5_0 = [u8_from_field_unsafe(d5_0_4[4] + 2 * d5_0_4[5] + 4 * d5_0_4[6] + 8 * d5_0_4[7] + 16 * d5_0_5[0] + 32 * d5_0_5[1] + 64 * d5_0_5[2] + 128 * d5_0_5[3]), u8_from_field_unsafe(d5_0_5[4] + 2 * d5_0_5[5] + 4 * d5_0_5[6] + 8 * d5_0_5[7] + 16 * d5_0_6[0] + 32 * d5_0_6[1] + 64 * d5_0_6[2] + 128 * d5_0_6[3]), u8_from_field_unsafe(d5_0_6[4] + 2 * d5_0_6[5] + 4 * d5_0_6[6] + 8 * d5_0_6[7] + 16 * d5_0_7[0] + 32 * d5_0_7[1] + 64 * d5_0_7[2] + 128 * d5_0_7[3]), u8_from_field_unsafe(d5_0_7[4] + 2 * d5_0_7[5] + 4 * d5_0_7[6] + 8 * d5_0_7[7] + 16 * d5_0_0[0] + 32 * d5_0_0[1] + 64 * d5_0_0[2] + 128 * d5_0_0[3]), u8_from_field_unsafe(d5_0_0[4] + 2 * d5_0_0[5] + 4 * d5_0_0[6] + 8 * d5_0_0[7] + 16 * d5_0_1[0] + 32 * d5_0_1[1] + 64 * d5_0_1[2] + 128 * d5_0_1[3]), u8_from_field_unsafe(d5_0_1[4] + 2 * d5_0_1[5] + 4 * d5_0_1[6] + 8 * d5_0_1[7] + 16 * d5_0_2[0] + 32 * d5_0_2[1] + 64 * d5_0_2[2] + 128 * d5_0_2[3]), u8_from_field_unsafe(d5_0_2[4] + 2 * d5_0_2[5] + 4 * d5_0_2[6] + 8 * d5_0_2[7] + 16 * d5_0_3[0] + 32 * d5_0_3[1] + 64 * d5_0_3[2] + 128 * d5_0_3[3]), u8_from_field_unsafe(d5_0_3[4] + 2 * d5_0_3[5] + 4 * d5_0_3[6] + 8 * d5_0_3[7] + 16 * d5_0_4[0] + 32 * d5_0_4[1] + 64 * d5_0_4[2] + 128 * d5_0_4[3])];
-      -- b15_0 = rotl(t4, 27) = byte-rotl 3 + 3x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a15_0_0_0, c15_0_0_0) = u8_add(t4_0[5], t4_0[5]);
-      let (a15_0_0_1, c15_0_0_1) = u8_add(t4_0[6], t4_0[6]);
-      let (a15_0_0_2, c15_0_0_2) = u8_add(t4_0[7], t4_0[7]);
-      let (a15_0_0_3, c15_0_0_3) = u8_add(t4_0[0], t4_0[0]);
-      let (a15_0_0_4, c15_0_0_4) = u8_add(t4_0[1], t4_0[1]);
-      let (a15_0_0_5, c15_0_0_5) = u8_add(t4_0[2], t4_0[2]);
-      let (a15_0_0_6, c15_0_0_6) = u8_add(t4_0[3], t4_0[3]);
-      let (a15_0_0_7, c15_0_0_7) = u8_add(t4_0[4], t4_0[4]);
-      let (a15_0_1_0, c15_0_1_0) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_0) + to_field(c15_0_0_7)), u8_from_field_unsafe(to_field(a15_0_0_0) + to_field(c15_0_0_7)));
-      let (a15_0_1_1, c15_0_1_1) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_1) + to_field(c15_0_0_0)), u8_from_field_unsafe(to_field(a15_0_0_1) + to_field(c15_0_0_0)));
-      let (a15_0_1_2, c15_0_1_2) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_2) + to_field(c15_0_0_1)), u8_from_field_unsafe(to_field(a15_0_0_2) + to_field(c15_0_0_1)));
-      let (a15_0_1_3, c15_0_1_3) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_3) + to_field(c15_0_0_2)), u8_from_field_unsafe(to_field(a15_0_0_3) + to_field(c15_0_0_2)));
-      let (a15_0_1_4, c15_0_1_4) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_4) + to_field(c15_0_0_3)), u8_from_field_unsafe(to_field(a15_0_0_4) + to_field(c15_0_0_3)));
-      let (a15_0_1_5, c15_0_1_5) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_5) + to_field(c15_0_0_4)), u8_from_field_unsafe(to_field(a15_0_0_5) + to_field(c15_0_0_4)));
-      let (a15_0_1_6, c15_0_1_6) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_6) + to_field(c15_0_0_5)), u8_from_field_unsafe(to_field(a15_0_0_6) + to_field(c15_0_0_5)));
-      let (a15_0_1_7, c15_0_1_7) = u8_add(u8_from_field_unsafe(to_field(a15_0_0_7) + to_field(c15_0_0_6)), u8_from_field_unsafe(to_field(a15_0_0_7) + to_field(c15_0_0_6)));
-      let (a15_0_2_0, c15_0_2_0) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_0) + to_field(c15_0_1_7)), u8_from_field_unsafe(to_field(a15_0_1_0) + to_field(c15_0_1_7)));
-      let (a15_0_2_1, c15_0_2_1) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_1) + to_field(c15_0_1_0)), u8_from_field_unsafe(to_field(a15_0_1_1) + to_field(c15_0_1_0)));
-      let (a15_0_2_2, c15_0_2_2) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_2) + to_field(c15_0_1_1)), u8_from_field_unsafe(to_field(a15_0_1_2) + to_field(c15_0_1_1)));
-      let (a15_0_2_3, c15_0_2_3) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_3) + to_field(c15_0_1_2)), u8_from_field_unsafe(to_field(a15_0_1_3) + to_field(c15_0_1_2)));
-      let (a15_0_2_4, c15_0_2_4) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_4) + to_field(c15_0_1_3)), u8_from_field_unsafe(to_field(a15_0_1_4) + to_field(c15_0_1_3)));
-      let (a15_0_2_5, c15_0_2_5) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_5) + to_field(c15_0_1_4)), u8_from_field_unsafe(to_field(a15_0_1_5) + to_field(c15_0_1_4)));
-      let (a15_0_2_6, c15_0_2_6) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_6) + to_field(c15_0_1_5)), u8_from_field_unsafe(to_field(a15_0_1_6) + to_field(c15_0_1_5)));
-      let (a15_0_2_7, c15_0_2_7) = u8_add(u8_from_field_unsafe(to_field(a15_0_1_7) + to_field(c15_0_1_6)), u8_from_field_unsafe(to_field(a15_0_1_7) + to_field(c15_0_1_6)));
-      let b15_0 = [u8_from_field_unsafe(to_field(a15_0_2_0) + to_field(c15_0_2_7)), u8_from_field_unsafe(to_field(a15_0_2_1) + to_field(c15_0_2_0)), u8_from_field_unsafe(to_field(a15_0_2_2) + to_field(c15_0_2_1)), u8_from_field_unsafe(to_field(a15_0_2_3) + to_field(c15_0_2_2)), u8_from_field_unsafe(to_field(a15_0_2_4) + to_field(c15_0_2_3)), u8_from_field_unsafe(to_field(a15_0_2_5) + to_field(c15_0_2_4)), u8_from_field_unsafe(to_field(a15_0_2_6) + to_field(c15_0_2_5)), u8_from_field_unsafe(to_field(a15_0_2_7) + to_field(c15_0_2_6))];
-      -- b16_0 = rotl(t5, 36) = byte-rotl 4 + bit-shl 4 (decomposition)
-      let d16_0_0 = u8_bit_decomposition(t5_0[0]);
-      let d16_0_1 = u8_bit_decomposition(t5_0[1]);
-      let d16_0_2 = u8_bit_decomposition(t5_0[2]);
-      let d16_0_3 = u8_bit_decomposition(t5_0[3]);
-      let d16_0_4 = u8_bit_decomposition(t5_0[4]);
-      let d16_0_5 = u8_bit_decomposition(t5_0[5]);
-      let d16_0_6 = u8_bit_decomposition(t5_0[6]);
-      let d16_0_7 = u8_bit_decomposition(t5_0[7]);
-      let b16_0 = [u8_from_field_unsafe(d16_0_3[4] + 2 * d16_0_3[5] + 4 * d16_0_3[6] + 8 * d16_0_3[7] + 16 * d16_0_4[0] + 32 * d16_0_4[1] + 64 * d16_0_4[2] + 128 * d16_0_4[3]), u8_from_field_unsafe(d16_0_4[4] + 2 * d16_0_4[5] + 4 * d16_0_4[6] + 8 * d16_0_4[7] + 16 * d16_0_5[0] + 32 * d16_0_5[1] + 64 * d16_0_5[2] + 128 * d16_0_5[3]), u8_from_field_unsafe(d16_0_5[4] + 2 * d16_0_5[5] + 4 * d16_0_5[6] + 8 * d16_0_5[7] + 16 * d16_0_6[0] + 32 * d16_0_6[1] + 64 * d16_0_6[2] + 128 * d16_0_6[3]), u8_from_field_unsafe(d16_0_6[4] + 2 * d16_0_6[5] + 4 * d16_0_6[6] + 8 * d16_0_6[7] + 16 * d16_0_7[0] + 32 * d16_0_7[1] + 64 * d16_0_7[2] + 128 * d16_0_7[3]), u8_from_field_unsafe(d16_0_7[4] + 2 * d16_0_7[5] + 4 * d16_0_7[6] + 8 * d16_0_7[7] + 16 * d16_0_0[0] + 32 * d16_0_0[1] + 64 * d16_0_0[2] + 128 * d16_0_0[3]), u8_from_field_unsafe(d16_0_0[4] + 2 * d16_0_0[5] + 4 * d16_0_0[6] + 8 * d16_0_0[7] + 16 * d16_0_1[0] + 32 * d16_0_1[1] + 64 * d16_0_1[2] + 128 * d16_0_1[3]), u8_from_field_unsafe(d16_0_1[4] + 2 * d16_0_1[5] + 4 * d16_0_1[6] + 8 * d16_0_1[7] + 16 * d16_0_2[0] + 32 * d16_0_2[1] + 64 * d16_0_2[2] + 128 * d16_0_2[3]), u8_from_field_unsafe(d16_0_2[4] + 2 * d16_0_2[5] + 4 * d16_0_2[6] + 8 * d16_0_2[7] + 16 * d16_0_3[0] + 32 * d16_0_3[1] + 64 * d16_0_3[2] + 128 * d16_0_3[3])];
-      -- b1_0 = rotl(t6, 44) = byte-rotl 5 + bit-shl 4 (decomposition)
-      let d1_0_0 = u8_bit_decomposition(t6_0[0]);
-      let d1_0_1 = u8_bit_decomposition(t6_0[1]);
-      let d1_0_2 = u8_bit_decomposition(t6_0[2]);
-      let d1_0_3 = u8_bit_decomposition(t6_0[3]);
-      let d1_0_4 = u8_bit_decomposition(t6_0[4]);
-      let d1_0_5 = u8_bit_decomposition(t6_0[5]);
-      let d1_0_6 = u8_bit_decomposition(t6_0[6]);
-      let d1_0_7 = u8_bit_decomposition(t6_0[7]);
-      let b1_0 = [u8_from_field_unsafe(d1_0_2[4] + 2 * d1_0_2[5] + 4 * d1_0_2[6] + 8 * d1_0_2[7] + 16 * d1_0_3[0] + 32 * d1_0_3[1] + 64 * d1_0_3[2] + 128 * d1_0_3[3]), u8_from_field_unsafe(d1_0_3[4] + 2 * d1_0_3[5] + 4 * d1_0_3[6] + 8 * d1_0_3[7] + 16 * d1_0_4[0] + 32 * d1_0_4[1] + 64 * d1_0_4[2] + 128 * d1_0_4[3]), u8_from_field_unsafe(d1_0_4[4] + 2 * d1_0_4[5] + 4 * d1_0_4[6] + 8 * d1_0_4[7] + 16 * d1_0_5[0] + 32 * d1_0_5[1] + 64 * d1_0_5[2] + 128 * d1_0_5[3]), u8_from_field_unsafe(d1_0_5[4] + 2 * d1_0_5[5] + 4 * d1_0_5[6] + 8 * d1_0_5[7] + 16 * d1_0_6[0] + 32 * d1_0_6[1] + 64 * d1_0_6[2] + 128 * d1_0_6[3]), u8_from_field_unsafe(d1_0_6[4] + 2 * d1_0_6[5] + 4 * d1_0_6[6] + 8 * d1_0_6[7] + 16 * d1_0_7[0] + 32 * d1_0_7[1] + 64 * d1_0_7[2] + 128 * d1_0_7[3]), u8_from_field_unsafe(d1_0_7[4] + 2 * d1_0_7[5] + 4 * d1_0_7[6] + 8 * d1_0_7[7] + 16 * d1_0_0[0] + 32 * d1_0_0[1] + 64 * d1_0_0[2] + 128 * d1_0_0[3]), u8_from_field_unsafe(d1_0_0[4] + 2 * d1_0_0[5] + 4 * d1_0_0[6] + 8 * d1_0_0[7] + 16 * d1_0_1[0] + 32 * d1_0_1[1] + 64 * d1_0_1[2] + 128 * d1_0_1[3]), u8_from_field_unsafe(d1_0_1[4] + 2 * d1_0_1[5] + 4 * d1_0_1[6] + 8 * d1_0_1[7] + 16 * d1_0_2[0] + 32 * d1_0_2[1] + 64 * d1_0_2[2] + 128 * d1_0_2[3])];
-      -- b11_0 = rotl(t7, 6) = byte-rotl 1 + 2x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h11_0_0_0 = u8_shift_right(t7_0[7]);
-      let h11_0_0_1 = u8_shift_right(t7_0[0]);
-      let h11_0_0_2 = u8_shift_right(t7_0[1]);
-      let h11_0_0_3 = u8_shift_right(t7_0[2]);
-      let h11_0_0_4 = u8_shift_right(t7_0[3]);
-      let h11_0_0_5 = u8_shift_right(t7_0[4]);
-      let h11_0_0_6 = u8_shift_right(t7_0[5]);
-      let h11_0_0_7 = u8_shift_right(t7_0[6]);
-      let h11_0_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_0) + 128 * (to_field(t7_0[0]) - 2 * to_field(h11_0_0_1))));
-      let h11_0_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_1) + 128 * (to_field(t7_0[1]) - 2 * to_field(h11_0_0_2))));
-      let h11_0_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_2) + 128 * (to_field(t7_0[2]) - 2 * to_field(h11_0_0_3))));
-      let h11_0_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_3) + 128 * (to_field(t7_0[3]) - 2 * to_field(h11_0_0_4))));
-      let h11_0_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_4) + 128 * (to_field(t7_0[4]) - 2 * to_field(h11_0_0_5))));
-      let h11_0_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_5) + 128 * (to_field(t7_0[5]) - 2 * to_field(h11_0_0_6))));
-      let h11_0_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_6) + 128 * (to_field(t7_0[6]) - 2 * to_field(h11_0_0_7))));
-      let h11_0_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h11_0_0_7) + 128 * (to_field(t7_0[7]) - 2 * to_field(h11_0_0_0))));
-      let b11_0 = [u8_from_field_unsafe(to_field(h11_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_1) + 128 * (to_field(t7_0[1]) - 2 * to_field(h11_0_0_2)))) - 2 * to_field(h11_0_1_1))), u8_from_field_unsafe(to_field(h11_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_2) + 128 * (to_field(t7_0[2]) - 2 * to_field(h11_0_0_3)))) - 2 * to_field(h11_0_1_2))), u8_from_field_unsafe(to_field(h11_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_3) + 128 * (to_field(t7_0[3]) - 2 * to_field(h11_0_0_4)))) - 2 * to_field(h11_0_1_3))), u8_from_field_unsafe(to_field(h11_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_4) + 128 * (to_field(t7_0[4]) - 2 * to_field(h11_0_0_5)))) - 2 * to_field(h11_0_1_4))), u8_from_field_unsafe(to_field(h11_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_5) + 128 * (to_field(t7_0[5]) - 2 * to_field(h11_0_0_6)))) - 2 * to_field(h11_0_1_5))), u8_from_field_unsafe(to_field(h11_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_6) + 128 * (to_field(t7_0[6]) - 2 * to_field(h11_0_0_7)))) - 2 * to_field(h11_0_1_6))), u8_from_field_unsafe(to_field(h11_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_7) + 128 * (to_field(t7_0[7]) - 2 * to_field(h11_0_0_0)))) - 2 * to_field(h11_0_1_7))), u8_from_field_unsafe(to_field(h11_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h11_0_0_0) + 128 * (to_field(t7_0[0]) - 2 * to_field(h11_0_0_1)))) - 2 * to_field(h11_0_1_0)))];
-      -- b21_0 = rotl(t8, 55) = byte-rotl 7 + 1x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h21_0_0_0 = u8_shift_right(t8_0[1]);
-      let h21_0_0_1 = u8_shift_right(t8_0[2]);
-      let h21_0_0_2 = u8_shift_right(t8_0[3]);
-      let h21_0_0_3 = u8_shift_right(t8_0[4]);
-      let h21_0_0_4 = u8_shift_right(t8_0[5]);
-      let h21_0_0_5 = u8_shift_right(t8_0[6]);
-      let h21_0_0_6 = u8_shift_right(t8_0[7]);
-      let h21_0_0_7 = u8_shift_right(t8_0[0]);
-      let b21_0 = [u8_from_field_unsafe(to_field(h21_0_0_0) + 128 * (to_field(t8_0[2]) - 2 * to_field(h21_0_0_1))), u8_from_field_unsafe(to_field(h21_0_0_1) + 128 * (to_field(t8_0[3]) - 2 * to_field(h21_0_0_2))), u8_from_field_unsafe(to_field(h21_0_0_2) + 128 * (to_field(t8_0[4]) - 2 * to_field(h21_0_0_3))), u8_from_field_unsafe(to_field(h21_0_0_3) + 128 * (to_field(t8_0[5]) - 2 * to_field(h21_0_0_4))), u8_from_field_unsafe(to_field(h21_0_0_4) + 128 * (to_field(t8_0[6]) - 2 * to_field(h21_0_0_5))), u8_from_field_unsafe(to_field(h21_0_0_5) + 128 * (to_field(t8_0[7]) - 2 * to_field(h21_0_0_6))), u8_from_field_unsafe(to_field(h21_0_0_6) + 128 * (to_field(t8_0[0]) - 2 * to_field(h21_0_0_7))), u8_from_field_unsafe(to_field(h21_0_0_7) + 128 * (to_field(t8_0[1]) - 2 * to_field(h21_0_0_0)))];
-      -- b6_0 = rotl(t9, 20) = byte-rotl 2 + bit-shl 4 (decomposition)
-      let d6_0_0 = u8_bit_decomposition(t9_0[0]);
-      let d6_0_1 = u8_bit_decomposition(t9_0[1]);
-      let d6_0_2 = u8_bit_decomposition(t9_0[2]);
-      let d6_0_3 = u8_bit_decomposition(t9_0[3]);
-      let d6_0_4 = u8_bit_decomposition(t9_0[4]);
-      let d6_0_5 = u8_bit_decomposition(t9_0[5]);
-      let d6_0_6 = u8_bit_decomposition(t9_0[6]);
-      let d6_0_7 = u8_bit_decomposition(t9_0[7]);
-      let b6_0 = [u8_from_field_unsafe(d6_0_5[4] + 2 * d6_0_5[5] + 4 * d6_0_5[6] + 8 * d6_0_5[7] + 16 * d6_0_6[0] + 32 * d6_0_6[1] + 64 * d6_0_6[2] + 128 * d6_0_6[3]), u8_from_field_unsafe(d6_0_6[4] + 2 * d6_0_6[5] + 4 * d6_0_6[6] + 8 * d6_0_6[7] + 16 * d6_0_7[0] + 32 * d6_0_7[1] + 64 * d6_0_7[2] + 128 * d6_0_7[3]), u8_from_field_unsafe(d6_0_7[4] + 2 * d6_0_7[5] + 4 * d6_0_7[6] + 8 * d6_0_7[7] + 16 * d6_0_0[0] + 32 * d6_0_0[1] + 64 * d6_0_0[2] + 128 * d6_0_0[3]), u8_from_field_unsafe(d6_0_0[4] + 2 * d6_0_0[5] + 4 * d6_0_0[6] + 8 * d6_0_0[7] + 16 * d6_0_1[0] + 32 * d6_0_1[1] + 64 * d6_0_1[2] + 128 * d6_0_1[3]), u8_from_field_unsafe(d6_0_1[4] + 2 * d6_0_1[5] + 4 * d6_0_1[6] + 8 * d6_0_1[7] + 16 * d6_0_2[0] + 32 * d6_0_2[1] + 64 * d6_0_2[2] + 128 * d6_0_2[3]), u8_from_field_unsafe(d6_0_2[4] + 2 * d6_0_2[5] + 4 * d6_0_2[6] + 8 * d6_0_2[7] + 16 * d6_0_3[0] + 32 * d6_0_3[1] + 64 * d6_0_3[2] + 128 * d6_0_3[3]), u8_from_field_unsafe(d6_0_3[4] + 2 * d6_0_3[5] + 4 * d6_0_3[6] + 8 * d6_0_3[7] + 16 * d6_0_4[0] + 32 * d6_0_4[1] + 64 * d6_0_4[2] + 128 * d6_0_4[3]), u8_from_field_unsafe(d6_0_4[4] + 2 * d6_0_4[5] + 4 * d6_0_4[6] + 8 * d6_0_4[7] + 16 * d6_0_5[0] + 32 * d6_0_5[1] + 64 * d6_0_5[2] + 128 * d6_0_5[3])];
-      -- b7_0 = rotl(t10, 3) = byte-rotl 0 + 3x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a7_0_0_0, c7_0_0_0) = u8_add(t10_0[0], t10_0[0]);
-      let (a7_0_0_1, c7_0_0_1) = u8_add(t10_0[1], t10_0[1]);
-      let (a7_0_0_2, c7_0_0_2) = u8_add(t10_0[2], t10_0[2]);
-      let (a7_0_0_3, c7_0_0_3) = u8_add(t10_0[3], t10_0[3]);
-      let (a7_0_0_4, c7_0_0_4) = u8_add(t10_0[4], t10_0[4]);
-      let (a7_0_0_5, c7_0_0_5) = u8_add(t10_0[5], t10_0[5]);
-      let (a7_0_0_6, c7_0_0_6) = u8_add(t10_0[6], t10_0[6]);
-      let (a7_0_0_7, c7_0_0_7) = u8_add(t10_0[7], t10_0[7]);
-      let (a7_0_1_0, c7_0_1_0) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_0) + to_field(c7_0_0_7)), u8_from_field_unsafe(to_field(a7_0_0_0) + to_field(c7_0_0_7)));
-      let (a7_0_1_1, c7_0_1_1) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_1) + to_field(c7_0_0_0)), u8_from_field_unsafe(to_field(a7_0_0_1) + to_field(c7_0_0_0)));
-      let (a7_0_1_2, c7_0_1_2) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_2) + to_field(c7_0_0_1)), u8_from_field_unsafe(to_field(a7_0_0_2) + to_field(c7_0_0_1)));
-      let (a7_0_1_3, c7_0_1_3) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_3) + to_field(c7_0_0_2)), u8_from_field_unsafe(to_field(a7_0_0_3) + to_field(c7_0_0_2)));
-      let (a7_0_1_4, c7_0_1_4) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_4) + to_field(c7_0_0_3)), u8_from_field_unsafe(to_field(a7_0_0_4) + to_field(c7_0_0_3)));
-      let (a7_0_1_5, c7_0_1_5) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_5) + to_field(c7_0_0_4)), u8_from_field_unsafe(to_field(a7_0_0_5) + to_field(c7_0_0_4)));
-      let (a7_0_1_6, c7_0_1_6) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_6) + to_field(c7_0_0_5)), u8_from_field_unsafe(to_field(a7_0_0_6) + to_field(c7_0_0_5)));
-      let (a7_0_1_7, c7_0_1_7) = u8_add(u8_from_field_unsafe(to_field(a7_0_0_7) + to_field(c7_0_0_6)), u8_from_field_unsafe(to_field(a7_0_0_7) + to_field(c7_0_0_6)));
-      let (a7_0_2_0, c7_0_2_0) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_0) + to_field(c7_0_1_7)), u8_from_field_unsafe(to_field(a7_0_1_0) + to_field(c7_0_1_7)));
-      let (a7_0_2_1, c7_0_2_1) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_1) + to_field(c7_0_1_0)), u8_from_field_unsafe(to_field(a7_0_1_1) + to_field(c7_0_1_0)));
-      let (a7_0_2_2, c7_0_2_2) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_2) + to_field(c7_0_1_1)), u8_from_field_unsafe(to_field(a7_0_1_2) + to_field(c7_0_1_1)));
-      let (a7_0_2_3, c7_0_2_3) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_3) + to_field(c7_0_1_2)), u8_from_field_unsafe(to_field(a7_0_1_3) + to_field(c7_0_1_2)));
-      let (a7_0_2_4, c7_0_2_4) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_4) + to_field(c7_0_1_3)), u8_from_field_unsafe(to_field(a7_0_1_4) + to_field(c7_0_1_3)));
-      let (a7_0_2_5, c7_0_2_5) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_5) + to_field(c7_0_1_4)), u8_from_field_unsafe(to_field(a7_0_1_5) + to_field(c7_0_1_4)));
-      let (a7_0_2_6, c7_0_2_6) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_6) + to_field(c7_0_1_5)), u8_from_field_unsafe(to_field(a7_0_1_6) + to_field(c7_0_1_5)));
-      let (a7_0_2_7, c7_0_2_7) = u8_add(u8_from_field_unsafe(to_field(a7_0_1_7) + to_field(c7_0_1_6)), u8_from_field_unsafe(to_field(a7_0_1_7) + to_field(c7_0_1_6)));
-      let b7_0 = [u8_from_field_unsafe(to_field(a7_0_2_0) + to_field(c7_0_2_7)), u8_from_field_unsafe(to_field(a7_0_2_1) + to_field(c7_0_2_0)), u8_from_field_unsafe(to_field(a7_0_2_2) + to_field(c7_0_2_1)), u8_from_field_unsafe(to_field(a7_0_2_3) + to_field(c7_0_2_2)), u8_from_field_unsafe(to_field(a7_0_2_4) + to_field(c7_0_2_3)), u8_from_field_unsafe(to_field(a7_0_2_5) + to_field(c7_0_2_4)), u8_from_field_unsafe(to_field(a7_0_2_6) + to_field(c7_0_2_5)), u8_from_field_unsafe(to_field(a7_0_2_7) + to_field(c7_0_2_6))];
-      -- b17_0 = rotl(t11, 10) = byte-rotl 1 + 2x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a17_0_0_0, c17_0_0_0) = u8_add(t11_0[7], t11_0[7]);
-      let (a17_0_0_1, c17_0_0_1) = u8_add(t11_0[0], t11_0[0]);
-      let (a17_0_0_2, c17_0_0_2) = u8_add(t11_0[1], t11_0[1]);
-      let (a17_0_0_3, c17_0_0_3) = u8_add(t11_0[2], t11_0[2]);
-      let (a17_0_0_4, c17_0_0_4) = u8_add(t11_0[3], t11_0[3]);
-      let (a17_0_0_5, c17_0_0_5) = u8_add(t11_0[4], t11_0[4]);
-      let (a17_0_0_6, c17_0_0_6) = u8_add(t11_0[5], t11_0[5]);
-      let (a17_0_0_7, c17_0_0_7) = u8_add(t11_0[6], t11_0[6]);
-      let (a17_0_1_0, c17_0_1_0) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_0) + to_field(c17_0_0_7)), u8_from_field_unsafe(to_field(a17_0_0_0) + to_field(c17_0_0_7)));
-      let (a17_0_1_1, c17_0_1_1) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_1) + to_field(c17_0_0_0)), u8_from_field_unsafe(to_field(a17_0_0_1) + to_field(c17_0_0_0)));
-      let (a17_0_1_2, c17_0_1_2) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_2) + to_field(c17_0_0_1)), u8_from_field_unsafe(to_field(a17_0_0_2) + to_field(c17_0_0_1)));
-      let (a17_0_1_3, c17_0_1_3) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_3) + to_field(c17_0_0_2)), u8_from_field_unsafe(to_field(a17_0_0_3) + to_field(c17_0_0_2)));
-      let (a17_0_1_4, c17_0_1_4) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_4) + to_field(c17_0_0_3)), u8_from_field_unsafe(to_field(a17_0_0_4) + to_field(c17_0_0_3)));
-      let (a17_0_1_5, c17_0_1_5) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_5) + to_field(c17_0_0_4)), u8_from_field_unsafe(to_field(a17_0_0_5) + to_field(c17_0_0_4)));
-      let (a17_0_1_6, c17_0_1_6) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_6) + to_field(c17_0_0_5)), u8_from_field_unsafe(to_field(a17_0_0_6) + to_field(c17_0_0_5)));
-      let (a17_0_1_7, c17_0_1_7) = u8_add(u8_from_field_unsafe(to_field(a17_0_0_7) + to_field(c17_0_0_6)), u8_from_field_unsafe(to_field(a17_0_0_7) + to_field(c17_0_0_6)));
-      let b17_0 = [u8_from_field_unsafe(to_field(a17_0_1_0) + to_field(c17_0_1_7)), u8_from_field_unsafe(to_field(a17_0_1_1) + to_field(c17_0_1_0)), u8_from_field_unsafe(to_field(a17_0_1_2) + to_field(c17_0_1_1)), u8_from_field_unsafe(to_field(a17_0_1_3) + to_field(c17_0_1_2)), u8_from_field_unsafe(to_field(a17_0_1_4) + to_field(c17_0_1_3)), u8_from_field_unsafe(to_field(a17_0_1_5) + to_field(c17_0_1_4)), u8_from_field_unsafe(to_field(a17_0_1_6) + to_field(c17_0_1_5)), u8_from_field_unsafe(to_field(a17_0_1_7) + to_field(c17_0_1_6))];
-      -- b2_0 = rotl(t12, 43) = byte-rotl 5 + 3x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a2_0_0_0, c2_0_0_0) = u8_add(t12_0[3], t12_0[3]);
-      let (a2_0_0_1, c2_0_0_1) = u8_add(t12_0[4], t12_0[4]);
-      let (a2_0_0_2, c2_0_0_2) = u8_add(t12_0[5], t12_0[5]);
-      let (a2_0_0_3, c2_0_0_3) = u8_add(t12_0[6], t12_0[6]);
-      let (a2_0_0_4, c2_0_0_4) = u8_add(t12_0[7], t12_0[7]);
-      let (a2_0_0_5, c2_0_0_5) = u8_add(t12_0[0], t12_0[0]);
-      let (a2_0_0_6, c2_0_0_6) = u8_add(t12_0[1], t12_0[1]);
-      let (a2_0_0_7, c2_0_0_7) = u8_add(t12_0[2], t12_0[2]);
-      let (a2_0_1_0, c2_0_1_0) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_0) + to_field(c2_0_0_7)), u8_from_field_unsafe(to_field(a2_0_0_0) + to_field(c2_0_0_7)));
-      let (a2_0_1_1, c2_0_1_1) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_1) + to_field(c2_0_0_0)), u8_from_field_unsafe(to_field(a2_0_0_1) + to_field(c2_0_0_0)));
-      let (a2_0_1_2, c2_0_1_2) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_2) + to_field(c2_0_0_1)), u8_from_field_unsafe(to_field(a2_0_0_2) + to_field(c2_0_0_1)));
-      let (a2_0_1_3, c2_0_1_3) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_3) + to_field(c2_0_0_2)), u8_from_field_unsafe(to_field(a2_0_0_3) + to_field(c2_0_0_2)));
-      let (a2_0_1_4, c2_0_1_4) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_4) + to_field(c2_0_0_3)), u8_from_field_unsafe(to_field(a2_0_0_4) + to_field(c2_0_0_3)));
-      let (a2_0_1_5, c2_0_1_5) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_5) + to_field(c2_0_0_4)), u8_from_field_unsafe(to_field(a2_0_0_5) + to_field(c2_0_0_4)));
-      let (a2_0_1_6, c2_0_1_6) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_6) + to_field(c2_0_0_5)), u8_from_field_unsafe(to_field(a2_0_0_6) + to_field(c2_0_0_5)));
-      let (a2_0_1_7, c2_0_1_7) = u8_add(u8_from_field_unsafe(to_field(a2_0_0_7) + to_field(c2_0_0_6)), u8_from_field_unsafe(to_field(a2_0_0_7) + to_field(c2_0_0_6)));
-      let (a2_0_2_0, c2_0_2_0) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_0) + to_field(c2_0_1_7)), u8_from_field_unsafe(to_field(a2_0_1_0) + to_field(c2_0_1_7)));
-      let (a2_0_2_1, c2_0_2_1) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_1) + to_field(c2_0_1_0)), u8_from_field_unsafe(to_field(a2_0_1_1) + to_field(c2_0_1_0)));
-      let (a2_0_2_2, c2_0_2_2) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_2) + to_field(c2_0_1_1)), u8_from_field_unsafe(to_field(a2_0_1_2) + to_field(c2_0_1_1)));
-      let (a2_0_2_3, c2_0_2_3) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_3) + to_field(c2_0_1_2)), u8_from_field_unsafe(to_field(a2_0_1_3) + to_field(c2_0_1_2)));
-      let (a2_0_2_4, c2_0_2_4) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_4) + to_field(c2_0_1_3)), u8_from_field_unsafe(to_field(a2_0_1_4) + to_field(c2_0_1_3)));
-      let (a2_0_2_5, c2_0_2_5) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_5) + to_field(c2_0_1_4)), u8_from_field_unsafe(to_field(a2_0_1_5) + to_field(c2_0_1_4)));
-      let (a2_0_2_6, c2_0_2_6) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_6) + to_field(c2_0_1_5)), u8_from_field_unsafe(to_field(a2_0_1_6) + to_field(c2_0_1_5)));
-      let (a2_0_2_7, c2_0_2_7) = u8_add(u8_from_field_unsafe(to_field(a2_0_1_7) + to_field(c2_0_1_6)), u8_from_field_unsafe(to_field(a2_0_1_7) + to_field(c2_0_1_6)));
-      let b2_0 = [u8_from_field_unsafe(to_field(a2_0_2_0) + to_field(c2_0_2_7)), u8_from_field_unsafe(to_field(a2_0_2_1) + to_field(c2_0_2_0)), u8_from_field_unsafe(to_field(a2_0_2_2) + to_field(c2_0_2_1)), u8_from_field_unsafe(to_field(a2_0_2_3) + to_field(c2_0_2_2)), u8_from_field_unsafe(to_field(a2_0_2_4) + to_field(c2_0_2_3)), u8_from_field_unsafe(to_field(a2_0_2_5) + to_field(c2_0_2_4)), u8_from_field_unsafe(to_field(a2_0_2_6) + to_field(c2_0_2_5)), u8_from_field_unsafe(to_field(a2_0_2_7) + to_field(c2_0_2_6))];
-      -- b12_0 = rotl(t13, 25) = byte-rotl 3 + 1x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a12_0_0_0, c12_0_0_0) = u8_add(t13_0[5], t13_0[5]);
-      let (a12_0_0_1, c12_0_0_1) = u8_add(t13_0[6], t13_0[6]);
-      let (a12_0_0_2, c12_0_0_2) = u8_add(t13_0[7], t13_0[7]);
-      let (a12_0_0_3, c12_0_0_3) = u8_add(t13_0[0], t13_0[0]);
-      let (a12_0_0_4, c12_0_0_4) = u8_add(t13_0[1], t13_0[1]);
-      let (a12_0_0_5, c12_0_0_5) = u8_add(t13_0[2], t13_0[2]);
-      let (a12_0_0_6, c12_0_0_6) = u8_add(t13_0[3], t13_0[3]);
-      let (a12_0_0_7, c12_0_0_7) = u8_add(t13_0[4], t13_0[4]);
-      let b12_0 = [u8_from_field_unsafe(to_field(a12_0_0_0) + to_field(c12_0_0_7)), u8_from_field_unsafe(to_field(a12_0_0_1) + to_field(c12_0_0_0)), u8_from_field_unsafe(to_field(a12_0_0_2) + to_field(c12_0_0_1)), u8_from_field_unsafe(to_field(a12_0_0_3) + to_field(c12_0_0_2)), u8_from_field_unsafe(to_field(a12_0_0_4) + to_field(c12_0_0_3)), u8_from_field_unsafe(to_field(a12_0_0_5) + to_field(c12_0_0_4)), u8_from_field_unsafe(to_field(a12_0_0_6) + to_field(c12_0_0_5)), u8_from_field_unsafe(to_field(a12_0_0_7) + to_field(c12_0_0_6))];
-      -- b22_0 = rotl(t14, 39) = byte-rotl 5 + 1x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h22_0_0_0 = u8_shift_right(t14_0[3]);
-      let h22_0_0_1 = u8_shift_right(t14_0[4]);
-      let h22_0_0_2 = u8_shift_right(t14_0[5]);
-      let h22_0_0_3 = u8_shift_right(t14_0[6]);
-      let h22_0_0_4 = u8_shift_right(t14_0[7]);
-      let h22_0_0_5 = u8_shift_right(t14_0[0]);
-      let h22_0_0_6 = u8_shift_right(t14_0[1]);
-      let h22_0_0_7 = u8_shift_right(t14_0[2]);
-      let b22_0 = [u8_from_field_unsafe(to_field(h22_0_0_0) + 128 * (to_field(t14_0[4]) - 2 * to_field(h22_0_0_1))), u8_from_field_unsafe(to_field(h22_0_0_1) + 128 * (to_field(t14_0[5]) - 2 * to_field(h22_0_0_2))), u8_from_field_unsafe(to_field(h22_0_0_2) + 128 * (to_field(t14_0[6]) - 2 * to_field(h22_0_0_3))), u8_from_field_unsafe(to_field(h22_0_0_3) + 128 * (to_field(t14_0[7]) - 2 * to_field(h22_0_0_4))), u8_from_field_unsafe(to_field(h22_0_0_4) + 128 * (to_field(t14_0[0]) - 2 * to_field(h22_0_0_5))), u8_from_field_unsafe(to_field(h22_0_0_5) + 128 * (to_field(t14_0[1]) - 2 * to_field(h22_0_0_6))), u8_from_field_unsafe(to_field(h22_0_0_6) + 128 * (to_field(t14_0[2]) - 2 * to_field(h22_0_0_7))), u8_from_field_unsafe(to_field(h22_0_0_7) + 128 * (to_field(t14_0[3]) - 2 * to_field(h22_0_0_0)))];
-      -- b23_0 = rotl(t15, 41) = byte-rotl 5 + 1x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a23_0_0_0, c23_0_0_0) = u8_add(t15_0[3], t15_0[3]);
-      let (a23_0_0_1, c23_0_0_1) = u8_add(t15_0[4], t15_0[4]);
-      let (a23_0_0_2, c23_0_0_2) = u8_add(t15_0[5], t15_0[5]);
-      let (a23_0_0_3, c23_0_0_3) = u8_add(t15_0[6], t15_0[6]);
-      let (a23_0_0_4, c23_0_0_4) = u8_add(t15_0[7], t15_0[7]);
-      let (a23_0_0_5, c23_0_0_5) = u8_add(t15_0[0], t15_0[0]);
-      let (a23_0_0_6, c23_0_0_6) = u8_add(t15_0[1], t15_0[1]);
-      let (a23_0_0_7, c23_0_0_7) = u8_add(t15_0[2], t15_0[2]);
-      let b23_0 = [u8_from_field_unsafe(to_field(a23_0_0_0) + to_field(c23_0_0_7)), u8_from_field_unsafe(to_field(a23_0_0_1) + to_field(c23_0_0_0)), u8_from_field_unsafe(to_field(a23_0_0_2) + to_field(c23_0_0_1)), u8_from_field_unsafe(to_field(a23_0_0_3) + to_field(c23_0_0_2)), u8_from_field_unsafe(to_field(a23_0_0_4) + to_field(c23_0_0_3)), u8_from_field_unsafe(to_field(a23_0_0_5) + to_field(c23_0_0_4)), u8_from_field_unsafe(to_field(a23_0_0_6) + to_field(c23_0_0_5)), u8_from_field_unsafe(to_field(a23_0_0_7) + to_field(c23_0_0_6))];
-      -- b8_0 = rotl(t16, 45) = byte-rotl 6 + 3x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h8_0_0_0 = u8_shift_right(t16_0[2]);
-      let h8_0_0_1 = u8_shift_right(t16_0[3]);
-      let h8_0_0_2 = u8_shift_right(t16_0[4]);
-      let h8_0_0_3 = u8_shift_right(t16_0[5]);
-      let h8_0_0_4 = u8_shift_right(t16_0[6]);
-      let h8_0_0_5 = u8_shift_right(t16_0[7]);
-      let h8_0_0_6 = u8_shift_right(t16_0[0]);
-      let h8_0_0_7 = u8_shift_right(t16_0[1]);
-      let h8_0_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_0) + 128 * (to_field(t16_0[3]) - 2 * to_field(h8_0_0_1))));
-      let h8_0_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_1) + 128 * (to_field(t16_0[4]) - 2 * to_field(h8_0_0_2))));
-      let h8_0_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_2) + 128 * (to_field(t16_0[5]) - 2 * to_field(h8_0_0_3))));
-      let h8_0_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_3) + 128 * (to_field(t16_0[6]) - 2 * to_field(h8_0_0_4))));
-      let h8_0_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_4) + 128 * (to_field(t16_0[7]) - 2 * to_field(h8_0_0_5))));
-      let h8_0_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_5) + 128 * (to_field(t16_0[0]) - 2 * to_field(h8_0_0_6))));
-      let h8_0_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_6) + 128 * (to_field(t16_0[1]) - 2 * to_field(h8_0_0_7))));
-      let h8_0_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_0_7) + 128 * (to_field(t16_0[2]) - 2 * to_field(h8_0_0_0))));
-      let h8_0_2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_1) + 128 * (to_field(t16_0[4]) - 2 * to_field(h8_0_0_2)))) - 2 * to_field(h8_0_1_1))));
-      let h8_0_2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_2) + 128 * (to_field(t16_0[5]) - 2 * to_field(h8_0_0_3)))) - 2 * to_field(h8_0_1_2))));
-      let h8_0_2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_3) + 128 * (to_field(t16_0[6]) - 2 * to_field(h8_0_0_4)))) - 2 * to_field(h8_0_1_3))));
-      let h8_0_2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_4) + 128 * (to_field(t16_0[7]) - 2 * to_field(h8_0_0_5)))) - 2 * to_field(h8_0_1_4))));
-      let h8_0_2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_5) + 128 * (to_field(t16_0[0]) - 2 * to_field(h8_0_0_6)))) - 2 * to_field(h8_0_1_5))));
-      let h8_0_2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_6) + 128 * (to_field(t16_0[1]) - 2 * to_field(h8_0_0_7)))) - 2 * to_field(h8_0_1_6))));
-      let h8_0_2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_7) + 128 * (to_field(t16_0[2]) - 2 * to_field(h8_0_0_0)))) - 2 * to_field(h8_0_1_7))));
-      let h8_0_2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h8_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_0) + 128 * (to_field(t16_0[3]) - 2 * to_field(h8_0_0_1)))) - 2 * to_field(h8_0_1_0))));
-      let b8_0 = [u8_from_field_unsafe(to_field(h8_0_2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_2) + 128 * (to_field(t16_0[5]) - 2 * to_field(h8_0_0_3)))) - 2 * to_field(h8_0_1_2)))) - 2 * to_field(h8_0_2_1))), u8_from_field_unsafe(to_field(h8_0_2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_3) + 128 * (to_field(t16_0[6]) - 2 * to_field(h8_0_0_4)))) - 2 * to_field(h8_0_1_3)))) - 2 * to_field(h8_0_2_2))), u8_from_field_unsafe(to_field(h8_0_2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_4) + 128 * (to_field(t16_0[7]) - 2 * to_field(h8_0_0_5)))) - 2 * to_field(h8_0_1_4)))) - 2 * to_field(h8_0_2_3))), u8_from_field_unsafe(to_field(h8_0_2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_5) + 128 * (to_field(t16_0[0]) - 2 * to_field(h8_0_0_6)))) - 2 * to_field(h8_0_1_5)))) - 2 * to_field(h8_0_2_4))), u8_from_field_unsafe(to_field(h8_0_2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_6) + 128 * (to_field(t16_0[1]) - 2 * to_field(h8_0_0_7)))) - 2 * to_field(h8_0_1_6)))) - 2 * to_field(h8_0_2_5))), u8_from_field_unsafe(to_field(h8_0_2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_7) + 128 * (to_field(t16_0[2]) - 2 * to_field(h8_0_0_0)))) - 2 * to_field(h8_0_1_7)))) - 2 * to_field(h8_0_2_6))), u8_from_field_unsafe(to_field(h8_0_2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_0) + 128 * (to_field(t16_0[3]) - 2 * to_field(h8_0_0_1)))) - 2 * to_field(h8_0_1_0)))) - 2 * to_field(h8_0_2_7))), u8_from_field_unsafe(to_field(h8_0_2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h8_0_0_1) + 128 * (to_field(t16_0[4]) - 2 * to_field(h8_0_0_2)))) - 2 * to_field(h8_0_1_1)))) - 2 * to_field(h8_0_2_0)))];
-      -- b18_0 = rotl(t17, 15) = byte-rotl 2 + 1x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h18_0_0_0 = u8_shift_right(t17_0[6]);
-      let h18_0_0_1 = u8_shift_right(t17_0[7]);
-      let h18_0_0_2 = u8_shift_right(t17_0[0]);
-      let h18_0_0_3 = u8_shift_right(t17_0[1]);
-      let h18_0_0_4 = u8_shift_right(t17_0[2]);
-      let h18_0_0_5 = u8_shift_right(t17_0[3]);
-      let h18_0_0_6 = u8_shift_right(t17_0[4]);
-      let h18_0_0_7 = u8_shift_right(t17_0[5]);
-      let b18_0 = [u8_from_field_unsafe(to_field(h18_0_0_0) + 128 * (to_field(t17_0[7]) - 2 * to_field(h18_0_0_1))), u8_from_field_unsafe(to_field(h18_0_0_1) + 128 * (to_field(t17_0[0]) - 2 * to_field(h18_0_0_2))), u8_from_field_unsafe(to_field(h18_0_0_2) + 128 * (to_field(t17_0[1]) - 2 * to_field(h18_0_0_3))), u8_from_field_unsafe(to_field(h18_0_0_3) + 128 * (to_field(t17_0[2]) - 2 * to_field(h18_0_0_4))), u8_from_field_unsafe(to_field(h18_0_0_4) + 128 * (to_field(t17_0[3]) - 2 * to_field(h18_0_0_5))), u8_from_field_unsafe(to_field(h18_0_0_5) + 128 * (to_field(t17_0[4]) - 2 * to_field(h18_0_0_6))), u8_from_field_unsafe(to_field(h18_0_0_6) + 128 * (to_field(t17_0[5]) - 2 * to_field(h18_0_0_7))), u8_from_field_unsafe(to_field(h18_0_0_7) + 128 * (to_field(t17_0[6]) - 2 * to_field(h18_0_0_0)))];
-      -- b3_0 = rotl(t18, 21) = byte-rotl 3 + 3x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h3_0_0_0 = u8_shift_right(t18_0[5]);
-      let h3_0_0_1 = u8_shift_right(t18_0[6]);
-      let h3_0_0_2 = u8_shift_right(t18_0[7]);
-      let h3_0_0_3 = u8_shift_right(t18_0[0]);
-      let h3_0_0_4 = u8_shift_right(t18_0[1]);
-      let h3_0_0_5 = u8_shift_right(t18_0[2]);
-      let h3_0_0_6 = u8_shift_right(t18_0[3]);
-      let h3_0_0_7 = u8_shift_right(t18_0[4]);
-      let h3_0_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_0) + 128 * (to_field(t18_0[6]) - 2 * to_field(h3_0_0_1))));
-      let h3_0_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_1) + 128 * (to_field(t18_0[7]) - 2 * to_field(h3_0_0_2))));
-      let h3_0_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_2) + 128 * (to_field(t18_0[0]) - 2 * to_field(h3_0_0_3))));
-      let h3_0_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_3) + 128 * (to_field(t18_0[1]) - 2 * to_field(h3_0_0_4))));
-      let h3_0_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_4) + 128 * (to_field(t18_0[2]) - 2 * to_field(h3_0_0_5))));
-      let h3_0_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_5) + 128 * (to_field(t18_0[3]) - 2 * to_field(h3_0_0_6))));
-      let h3_0_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_6) + 128 * (to_field(t18_0[4]) - 2 * to_field(h3_0_0_7))));
-      let h3_0_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_0_7) + 128 * (to_field(t18_0[5]) - 2 * to_field(h3_0_0_0))));
-      let h3_0_2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_1) + 128 * (to_field(t18_0[7]) - 2 * to_field(h3_0_0_2)))) - 2 * to_field(h3_0_1_1))));
-      let h3_0_2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_2) + 128 * (to_field(t18_0[0]) - 2 * to_field(h3_0_0_3)))) - 2 * to_field(h3_0_1_2))));
-      let h3_0_2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_3) + 128 * (to_field(t18_0[1]) - 2 * to_field(h3_0_0_4)))) - 2 * to_field(h3_0_1_3))));
-      let h3_0_2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_4) + 128 * (to_field(t18_0[2]) - 2 * to_field(h3_0_0_5)))) - 2 * to_field(h3_0_1_4))));
-      let h3_0_2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_5) + 128 * (to_field(t18_0[3]) - 2 * to_field(h3_0_0_6)))) - 2 * to_field(h3_0_1_5))));
-      let h3_0_2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_6) + 128 * (to_field(t18_0[4]) - 2 * to_field(h3_0_0_7)))) - 2 * to_field(h3_0_1_6))));
-      let h3_0_2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_7) + 128 * (to_field(t18_0[5]) - 2 * to_field(h3_0_0_0)))) - 2 * to_field(h3_0_1_7))));
-      let h3_0_2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h3_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_0) + 128 * (to_field(t18_0[6]) - 2 * to_field(h3_0_0_1)))) - 2 * to_field(h3_0_1_0))));
-      let b3_0 = [u8_from_field_unsafe(to_field(h3_0_2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_2) + 128 * (to_field(t18_0[0]) - 2 * to_field(h3_0_0_3)))) - 2 * to_field(h3_0_1_2)))) - 2 * to_field(h3_0_2_1))), u8_from_field_unsafe(to_field(h3_0_2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_3) + 128 * (to_field(t18_0[1]) - 2 * to_field(h3_0_0_4)))) - 2 * to_field(h3_0_1_3)))) - 2 * to_field(h3_0_2_2))), u8_from_field_unsafe(to_field(h3_0_2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_4) + 128 * (to_field(t18_0[2]) - 2 * to_field(h3_0_0_5)))) - 2 * to_field(h3_0_1_4)))) - 2 * to_field(h3_0_2_3))), u8_from_field_unsafe(to_field(h3_0_2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_5) + 128 * (to_field(t18_0[3]) - 2 * to_field(h3_0_0_6)))) - 2 * to_field(h3_0_1_5)))) - 2 * to_field(h3_0_2_4))), u8_from_field_unsafe(to_field(h3_0_2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_6) + 128 * (to_field(t18_0[4]) - 2 * to_field(h3_0_0_7)))) - 2 * to_field(h3_0_1_6)))) - 2 * to_field(h3_0_2_5))), u8_from_field_unsafe(to_field(h3_0_2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_7) + 128 * (to_field(t18_0[5]) - 2 * to_field(h3_0_0_0)))) - 2 * to_field(h3_0_1_7)))) - 2 * to_field(h3_0_2_6))), u8_from_field_unsafe(to_field(h3_0_2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_0) + 128 * (to_field(t18_0[6]) - 2 * to_field(h3_0_0_1)))) - 2 * to_field(h3_0_1_0)))) - 2 * to_field(h3_0_2_7))), u8_from_field_unsafe(to_field(h3_0_2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h3_0_0_1) + 128 * (to_field(t18_0[7]) - 2 * to_field(h3_0_0_2)))) - 2 * to_field(h3_0_1_1)))) - 2 * to_field(h3_0_2_0)))];
-      -- b13_0 = rotl(t19, 8): byte rotation only (free)
-      let b13_0 = [t19_0[7], t19_0[0], t19_0[1], t19_0[2], t19_0[3], t19_0[4], t19_0[5], t19_0[6]];
-      -- b14_0 = rotl(t20, 18) = byte-rotl 2 + 2x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a14_0_0_0, c14_0_0_0) = u8_add(t20_0[6], t20_0[6]);
-      let (a14_0_0_1, c14_0_0_1) = u8_add(t20_0[7], t20_0[7]);
-      let (a14_0_0_2, c14_0_0_2) = u8_add(t20_0[0], t20_0[0]);
-      let (a14_0_0_3, c14_0_0_3) = u8_add(t20_0[1], t20_0[1]);
-      let (a14_0_0_4, c14_0_0_4) = u8_add(t20_0[2], t20_0[2]);
-      let (a14_0_0_5, c14_0_0_5) = u8_add(t20_0[3], t20_0[3]);
-      let (a14_0_0_6, c14_0_0_6) = u8_add(t20_0[4], t20_0[4]);
-      let (a14_0_0_7, c14_0_0_7) = u8_add(t20_0[5], t20_0[5]);
-      let (a14_0_1_0, c14_0_1_0) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_0) + to_field(c14_0_0_7)), u8_from_field_unsafe(to_field(a14_0_0_0) + to_field(c14_0_0_7)));
-      let (a14_0_1_1, c14_0_1_1) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_1) + to_field(c14_0_0_0)), u8_from_field_unsafe(to_field(a14_0_0_1) + to_field(c14_0_0_0)));
-      let (a14_0_1_2, c14_0_1_2) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_2) + to_field(c14_0_0_1)), u8_from_field_unsafe(to_field(a14_0_0_2) + to_field(c14_0_0_1)));
-      let (a14_0_1_3, c14_0_1_3) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_3) + to_field(c14_0_0_2)), u8_from_field_unsafe(to_field(a14_0_0_3) + to_field(c14_0_0_2)));
-      let (a14_0_1_4, c14_0_1_4) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_4) + to_field(c14_0_0_3)), u8_from_field_unsafe(to_field(a14_0_0_4) + to_field(c14_0_0_3)));
-      let (a14_0_1_5, c14_0_1_5) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_5) + to_field(c14_0_0_4)), u8_from_field_unsafe(to_field(a14_0_0_5) + to_field(c14_0_0_4)));
-      let (a14_0_1_6, c14_0_1_6) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_6) + to_field(c14_0_0_5)), u8_from_field_unsafe(to_field(a14_0_0_6) + to_field(c14_0_0_5)));
-      let (a14_0_1_7, c14_0_1_7) = u8_add(u8_from_field_unsafe(to_field(a14_0_0_7) + to_field(c14_0_0_6)), u8_from_field_unsafe(to_field(a14_0_0_7) + to_field(c14_0_0_6)));
-      let b14_0 = [u8_from_field_unsafe(to_field(a14_0_1_0) + to_field(c14_0_1_7)), u8_from_field_unsafe(to_field(a14_0_1_1) + to_field(c14_0_1_0)), u8_from_field_unsafe(to_field(a14_0_1_2) + to_field(c14_0_1_1)), u8_from_field_unsafe(to_field(a14_0_1_3) + to_field(c14_0_1_2)), u8_from_field_unsafe(to_field(a14_0_1_4) + to_field(c14_0_1_3)), u8_from_field_unsafe(to_field(a14_0_1_5) + to_field(c14_0_1_4)), u8_from_field_unsafe(to_field(a14_0_1_6) + to_field(c14_0_1_5)), u8_from_field_unsafe(to_field(a14_0_1_7) + to_field(c14_0_1_6))];
-      -- b24_0 = rotl(t21, 2) = byte-rotl 0 + 2x rotl1 (u8_add doubling: (b+b) = (2b mod 256, msb); the even low byte absorbs the neighbor's msb via free field add)
-      let (a24_0_0_0, c24_0_0_0) = u8_add(t21_0[0], t21_0[0]);
-      let (a24_0_0_1, c24_0_0_1) = u8_add(t21_0[1], t21_0[1]);
-      let (a24_0_0_2, c24_0_0_2) = u8_add(t21_0[2], t21_0[2]);
-      let (a24_0_0_3, c24_0_0_3) = u8_add(t21_0[3], t21_0[3]);
-      let (a24_0_0_4, c24_0_0_4) = u8_add(t21_0[4], t21_0[4]);
-      let (a24_0_0_5, c24_0_0_5) = u8_add(t21_0[5], t21_0[5]);
-      let (a24_0_0_6, c24_0_0_6) = u8_add(t21_0[6], t21_0[6]);
-      let (a24_0_0_7, c24_0_0_7) = u8_add(t21_0[7], t21_0[7]);
-      let (a24_0_1_0, c24_0_1_0) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_0) + to_field(c24_0_0_7)), u8_from_field_unsafe(to_field(a24_0_0_0) + to_field(c24_0_0_7)));
-      let (a24_0_1_1, c24_0_1_1) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_1) + to_field(c24_0_0_0)), u8_from_field_unsafe(to_field(a24_0_0_1) + to_field(c24_0_0_0)));
-      let (a24_0_1_2, c24_0_1_2) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_2) + to_field(c24_0_0_1)), u8_from_field_unsafe(to_field(a24_0_0_2) + to_field(c24_0_0_1)));
-      let (a24_0_1_3, c24_0_1_3) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_3) + to_field(c24_0_0_2)), u8_from_field_unsafe(to_field(a24_0_0_3) + to_field(c24_0_0_2)));
-      let (a24_0_1_4, c24_0_1_4) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_4) + to_field(c24_0_0_3)), u8_from_field_unsafe(to_field(a24_0_0_4) + to_field(c24_0_0_3)));
-      let (a24_0_1_5, c24_0_1_5) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_5) + to_field(c24_0_0_4)), u8_from_field_unsafe(to_field(a24_0_0_5) + to_field(c24_0_0_4)));
-      let (a24_0_1_6, c24_0_1_6) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_6) + to_field(c24_0_0_5)), u8_from_field_unsafe(to_field(a24_0_0_6) + to_field(c24_0_0_5)));
-      let (a24_0_1_7, c24_0_1_7) = u8_add(u8_from_field_unsafe(to_field(a24_0_0_7) + to_field(c24_0_0_6)), u8_from_field_unsafe(to_field(a24_0_0_7) + to_field(c24_0_0_6)));
-      let b24_0 = [u8_from_field_unsafe(to_field(a24_0_1_0) + to_field(c24_0_1_7)), u8_from_field_unsafe(to_field(a24_0_1_1) + to_field(c24_0_1_0)), u8_from_field_unsafe(to_field(a24_0_1_2) + to_field(c24_0_1_1)), u8_from_field_unsafe(to_field(a24_0_1_3) + to_field(c24_0_1_2)), u8_from_field_unsafe(to_field(a24_0_1_4) + to_field(c24_0_1_3)), u8_from_field_unsafe(to_field(a24_0_1_5) + to_field(c24_0_1_4)), u8_from_field_unsafe(to_field(a24_0_1_6) + to_field(c24_0_1_5)), u8_from_field_unsafe(to_field(a24_0_1_7) + to_field(c24_0_1_6))];
-      -- b9_0 = rotl(t22, 61) = byte-rotl 8 + 3x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h9_0_0_0 = u8_shift_right(t22_0[0]);
-      let h9_0_0_1 = u8_shift_right(t22_0[1]);
-      let h9_0_0_2 = u8_shift_right(t22_0[2]);
-      let h9_0_0_3 = u8_shift_right(t22_0[3]);
-      let h9_0_0_4 = u8_shift_right(t22_0[4]);
-      let h9_0_0_5 = u8_shift_right(t22_0[5]);
-      let h9_0_0_6 = u8_shift_right(t22_0[6]);
-      let h9_0_0_7 = u8_shift_right(t22_0[7]);
-      let h9_0_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_0) + 128 * (to_field(t22_0[1]) - 2 * to_field(h9_0_0_1))));
-      let h9_0_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_1) + 128 * (to_field(t22_0[2]) - 2 * to_field(h9_0_0_2))));
-      let h9_0_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_2) + 128 * (to_field(t22_0[3]) - 2 * to_field(h9_0_0_3))));
-      let h9_0_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_3) + 128 * (to_field(t22_0[4]) - 2 * to_field(h9_0_0_4))));
-      let h9_0_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_4) + 128 * (to_field(t22_0[5]) - 2 * to_field(h9_0_0_5))));
-      let h9_0_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_5) + 128 * (to_field(t22_0[6]) - 2 * to_field(h9_0_0_6))));
-      let h9_0_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_6) + 128 * (to_field(t22_0[7]) - 2 * to_field(h9_0_0_7))));
-      let h9_0_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_0_7) + 128 * (to_field(t22_0[0]) - 2 * to_field(h9_0_0_0))));
-      let h9_0_2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_1) + 128 * (to_field(t22_0[2]) - 2 * to_field(h9_0_0_2)))) - 2 * to_field(h9_0_1_1))));
-      let h9_0_2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_2) + 128 * (to_field(t22_0[3]) - 2 * to_field(h9_0_0_3)))) - 2 * to_field(h9_0_1_2))));
-      let h9_0_2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_3) + 128 * (to_field(t22_0[4]) - 2 * to_field(h9_0_0_4)))) - 2 * to_field(h9_0_1_3))));
-      let h9_0_2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_4) + 128 * (to_field(t22_0[5]) - 2 * to_field(h9_0_0_5)))) - 2 * to_field(h9_0_1_4))));
-      let h9_0_2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_5) + 128 * (to_field(t22_0[6]) - 2 * to_field(h9_0_0_6)))) - 2 * to_field(h9_0_1_5))));
-      let h9_0_2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_6) + 128 * (to_field(t22_0[7]) - 2 * to_field(h9_0_0_7)))) - 2 * to_field(h9_0_1_6))));
-      let h9_0_2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_7) + 128 * (to_field(t22_0[0]) - 2 * to_field(h9_0_0_0)))) - 2 * to_field(h9_0_1_7))));
-      let h9_0_2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h9_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_0) + 128 * (to_field(t22_0[1]) - 2 * to_field(h9_0_0_1)))) - 2 * to_field(h9_0_1_0))));
-      let b9_0 = [u8_from_field_unsafe(to_field(h9_0_2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_2) + 128 * (to_field(t22_0[3]) - 2 * to_field(h9_0_0_3)))) - 2 * to_field(h9_0_1_2)))) - 2 * to_field(h9_0_2_1))), u8_from_field_unsafe(to_field(h9_0_2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_3) + 128 * (to_field(t22_0[4]) - 2 * to_field(h9_0_0_4)))) - 2 * to_field(h9_0_1_3)))) - 2 * to_field(h9_0_2_2))), u8_from_field_unsafe(to_field(h9_0_2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_4) + 128 * (to_field(t22_0[5]) - 2 * to_field(h9_0_0_5)))) - 2 * to_field(h9_0_1_4)))) - 2 * to_field(h9_0_2_3))), u8_from_field_unsafe(to_field(h9_0_2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_5) + 128 * (to_field(t22_0[6]) - 2 * to_field(h9_0_0_6)))) - 2 * to_field(h9_0_1_5)))) - 2 * to_field(h9_0_2_4))), u8_from_field_unsafe(to_field(h9_0_2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_6) + 128 * (to_field(t22_0[7]) - 2 * to_field(h9_0_0_7)))) - 2 * to_field(h9_0_1_6)))) - 2 * to_field(h9_0_2_5))), u8_from_field_unsafe(to_field(h9_0_2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_7) + 128 * (to_field(t22_0[0]) - 2 * to_field(h9_0_0_0)))) - 2 * to_field(h9_0_1_7)))) - 2 * to_field(h9_0_2_6))), u8_from_field_unsafe(to_field(h9_0_2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_0) + 128 * (to_field(t22_0[1]) - 2 * to_field(h9_0_0_1)))) - 2 * to_field(h9_0_1_0)))) - 2 * to_field(h9_0_2_7))), u8_from_field_unsafe(to_field(h9_0_2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h9_0_0_1) + 128 * (to_field(t22_0[2]) - 2 * to_field(h9_0_0_2)))) - 2 * to_field(h9_0_1_1)))) - 2 * to_field(h9_0_2_0)))];
-      -- b19_0 = rotl(t23, 56): byte rotation only (free)
-      let b19_0 = [t23_0[1], t23_0[2], t23_0[3], t23_0[4], t23_0[5], t23_0[6], t23_0[7], t23_0[0]];
-      -- b4_0 = rotl(t24, 14) = byte-rotl 2 + 2x rotr1 (u8_shift_right drops the lsb, recovered as b - 2*(b >> 1) and recomposed into the neighbor's msb via free field add)
-      let h4_0_0_0 = u8_shift_right(t24_0[6]);
-      let h4_0_0_1 = u8_shift_right(t24_0[7]);
-      let h4_0_0_2 = u8_shift_right(t24_0[0]);
-      let h4_0_0_3 = u8_shift_right(t24_0[1]);
-      let h4_0_0_4 = u8_shift_right(t24_0[2]);
-      let h4_0_0_5 = u8_shift_right(t24_0[3]);
-      let h4_0_0_6 = u8_shift_right(t24_0[4]);
-      let h4_0_0_7 = u8_shift_right(t24_0[5]);
-      let h4_0_1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_0) + 128 * (to_field(t24_0[7]) - 2 * to_field(h4_0_0_1))));
-      let h4_0_1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_1) + 128 * (to_field(t24_0[0]) - 2 * to_field(h4_0_0_2))));
-      let h4_0_1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_2) + 128 * (to_field(t24_0[1]) - 2 * to_field(h4_0_0_3))));
-      let h4_0_1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_3) + 128 * (to_field(t24_0[2]) - 2 * to_field(h4_0_0_4))));
-      let h4_0_1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_4) + 128 * (to_field(t24_0[3]) - 2 * to_field(h4_0_0_5))));
-      let h4_0_1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_5) + 128 * (to_field(t24_0[4]) - 2 * to_field(h4_0_0_6))));
-      let h4_0_1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_6) + 128 * (to_field(t24_0[5]) - 2 * to_field(h4_0_0_7))));
-      let h4_0_1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h4_0_0_7) + 128 * (to_field(t24_0[6]) - 2 * to_field(h4_0_0_0))));
-      let b4_0 = [u8_from_field_unsafe(to_field(h4_0_1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_1) + 128 * (to_field(t24_0[0]) - 2 * to_field(h4_0_0_2)))) - 2 * to_field(h4_0_1_1))), u8_from_field_unsafe(to_field(h4_0_1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_2) + 128 * (to_field(t24_0[1]) - 2 * to_field(h4_0_0_3)))) - 2 * to_field(h4_0_1_2))), u8_from_field_unsafe(to_field(h4_0_1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_3) + 128 * (to_field(t24_0[2]) - 2 * to_field(h4_0_0_4)))) - 2 * to_field(h4_0_1_3))), u8_from_field_unsafe(to_field(h4_0_1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_4) + 128 * (to_field(t24_0[3]) - 2 * to_field(h4_0_0_5)))) - 2 * to_field(h4_0_1_4))), u8_from_field_unsafe(to_field(h4_0_1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_5) + 128 * (to_field(t24_0[4]) - 2 * to_field(h4_0_0_6)))) - 2 * to_field(h4_0_1_5))), u8_from_field_unsafe(to_field(h4_0_1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_6) + 128 * (to_field(t24_0[5]) - 2 * to_field(h4_0_0_7)))) - 2 * to_field(h4_0_1_6))), u8_from_field_unsafe(to_field(h4_0_1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_7) + 128 * (to_field(t24_0[6]) - 2 * to_field(h4_0_0_0)))) - 2 * to_field(h4_0_1_7))), u8_from_field_unsafe(to_field(h4_0_1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h4_0_0_0) + 128 * (to_field(t24_0[7]) - 2 * to_field(h4_0_0_1)))) - 2 * to_field(h4_0_1_0)))];
-      -- round 0: chi
-      let e0_0 = [u8_xor(b0_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[0])), b2_0[0])), u8_xor(b0_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[1])), b2_0[1])), u8_xor(b0_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[2])), b2_0[2])), u8_xor(b0_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[3])), b2_0[3])), u8_xor(b0_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[4])), b2_0[4])), u8_xor(b0_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[5])), b2_0[5])), u8_xor(b0_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[6])), b2_0[6])), u8_xor(b0_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b1_0[7])), b2_0[7]))];
-      let e1_0 = [u8_xor(b1_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[0])), b3_0[0])), u8_xor(b1_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[1])), b3_0[1])), u8_xor(b1_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[2])), b3_0[2])), u8_xor(b1_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[3])), b3_0[3])), u8_xor(b1_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[4])), b3_0[4])), u8_xor(b1_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[5])), b3_0[5])), u8_xor(b1_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[6])), b3_0[6])), u8_xor(b1_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b2_0[7])), b3_0[7]))];
-      let e2_0 = [u8_xor(b2_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[0])), b4_0[0])), u8_xor(b2_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[1])), b4_0[1])), u8_xor(b2_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[2])), b4_0[2])), u8_xor(b2_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[3])), b4_0[3])), u8_xor(b2_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[4])), b4_0[4])), u8_xor(b2_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[5])), b4_0[5])), u8_xor(b2_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[6])), b4_0[6])), u8_xor(b2_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b3_0[7])), b4_0[7]))];
-      let e3_0 = [u8_xor(b3_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[0])), b0_0[0])), u8_xor(b3_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[1])), b0_0[1])), u8_xor(b3_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[2])), b0_0[2])), u8_xor(b3_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[3])), b0_0[3])), u8_xor(b3_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[4])), b0_0[4])), u8_xor(b3_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[5])), b0_0[5])), u8_xor(b3_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[6])), b0_0[6])), u8_xor(b3_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b4_0[7])), b0_0[7]))];
-      let e4_0 = [u8_xor(b4_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[0])), b1_0[0])), u8_xor(b4_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[1])), b1_0[1])), u8_xor(b4_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[2])), b1_0[2])), u8_xor(b4_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[3])), b1_0[3])), u8_xor(b4_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[4])), b1_0[4])), u8_xor(b4_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[5])), b1_0[5])), u8_xor(b4_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[6])), b1_0[6])), u8_xor(b4_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b0_0[7])), b1_0[7]))];
-      let e5_0 = [u8_xor(b5_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[0])), b7_0[0])), u8_xor(b5_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[1])), b7_0[1])), u8_xor(b5_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[2])), b7_0[2])), u8_xor(b5_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[3])), b7_0[3])), u8_xor(b5_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[4])), b7_0[4])), u8_xor(b5_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[5])), b7_0[5])), u8_xor(b5_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[6])), b7_0[6])), u8_xor(b5_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b6_0[7])), b7_0[7]))];
-      let e6_0 = [u8_xor(b6_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[0])), b8_0[0])), u8_xor(b6_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[1])), b8_0[1])), u8_xor(b6_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[2])), b8_0[2])), u8_xor(b6_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[3])), b8_0[3])), u8_xor(b6_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[4])), b8_0[4])), u8_xor(b6_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[5])), b8_0[5])), u8_xor(b6_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[6])), b8_0[6])), u8_xor(b6_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b7_0[7])), b8_0[7]))];
-      let e7_0 = [u8_xor(b7_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[0])), b9_0[0])), u8_xor(b7_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[1])), b9_0[1])), u8_xor(b7_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[2])), b9_0[2])), u8_xor(b7_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[3])), b9_0[3])), u8_xor(b7_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[4])), b9_0[4])), u8_xor(b7_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[5])), b9_0[5])), u8_xor(b7_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[6])), b9_0[6])), u8_xor(b7_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b8_0[7])), b9_0[7]))];
-      let e8_0 = [u8_xor(b8_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[0])), b5_0[0])), u8_xor(b8_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[1])), b5_0[1])), u8_xor(b8_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[2])), b5_0[2])), u8_xor(b8_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[3])), b5_0[3])), u8_xor(b8_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[4])), b5_0[4])), u8_xor(b8_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[5])), b5_0[5])), u8_xor(b8_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[6])), b5_0[6])), u8_xor(b8_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b9_0[7])), b5_0[7]))];
-      let e9_0 = [u8_xor(b9_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[0])), b6_0[0])), u8_xor(b9_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[1])), b6_0[1])), u8_xor(b9_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[2])), b6_0[2])), u8_xor(b9_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[3])), b6_0[3])), u8_xor(b9_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[4])), b6_0[4])), u8_xor(b9_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[5])), b6_0[5])), u8_xor(b9_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[6])), b6_0[6])), u8_xor(b9_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b5_0[7])), b6_0[7]))];
-      let e10_0 = [u8_xor(b10_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[0])), b12_0[0])), u8_xor(b10_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[1])), b12_0[1])), u8_xor(b10_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[2])), b12_0[2])), u8_xor(b10_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[3])), b12_0[3])), u8_xor(b10_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[4])), b12_0[4])), u8_xor(b10_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[5])), b12_0[5])), u8_xor(b10_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[6])), b12_0[6])), u8_xor(b10_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b11_0[7])), b12_0[7]))];
-      let e11_0 = [u8_xor(b11_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[0])), b13_0[0])), u8_xor(b11_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[1])), b13_0[1])), u8_xor(b11_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[2])), b13_0[2])), u8_xor(b11_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[3])), b13_0[3])), u8_xor(b11_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[4])), b13_0[4])), u8_xor(b11_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[5])), b13_0[5])), u8_xor(b11_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[6])), b13_0[6])), u8_xor(b11_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b12_0[7])), b13_0[7]))];
-      let e12_0 = [u8_xor(b12_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[0])), b14_0[0])), u8_xor(b12_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[1])), b14_0[1])), u8_xor(b12_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[2])), b14_0[2])), u8_xor(b12_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[3])), b14_0[3])), u8_xor(b12_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[4])), b14_0[4])), u8_xor(b12_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[5])), b14_0[5])), u8_xor(b12_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[6])), b14_0[6])), u8_xor(b12_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b13_0[7])), b14_0[7]))];
-      let e13_0 = [u8_xor(b13_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[0])), b10_0[0])), u8_xor(b13_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[1])), b10_0[1])), u8_xor(b13_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[2])), b10_0[2])), u8_xor(b13_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[3])), b10_0[3])), u8_xor(b13_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[4])), b10_0[4])), u8_xor(b13_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[5])), b10_0[5])), u8_xor(b13_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[6])), b10_0[6])), u8_xor(b13_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b14_0[7])), b10_0[7]))];
-      let e14_0 = [u8_xor(b14_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[0])), b11_0[0])), u8_xor(b14_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[1])), b11_0[1])), u8_xor(b14_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[2])), b11_0[2])), u8_xor(b14_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[3])), b11_0[3])), u8_xor(b14_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[4])), b11_0[4])), u8_xor(b14_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[5])), b11_0[5])), u8_xor(b14_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[6])), b11_0[6])), u8_xor(b14_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b10_0[7])), b11_0[7]))];
-      let e15_0 = [u8_xor(b15_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[0])), b17_0[0])), u8_xor(b15_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[1])), b17_0[1])), u8_xor(b15_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[2])), b17_0[2])), u8_xor(b15_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[3])), b17_0[3])), u8_xor(b15_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[4])), b17_0[4])), u8_xor(b15_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[5])), b17_0[5])), u8_xor(b15_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[6])), b17_0[6])), u8_xor(b15_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b16_0[7])), b17_0[7]))];
-      let e16_0 = [u8_xor(b16_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[0])), b18_0[0])), u8_xor(b16_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[1])), b18_0[1])), u8_xor(b16_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[2])), b18_0[2])), u8_xor(b16_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[3])), b18_0[3])), u8_xor(b16_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[4])), b18_0[4])), u8_xor(b16_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[5])), b18_0[5])), u8_xor(b16_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[6])), b18_0[6])), u8_xor(b16_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b17_0[7])), b18_0[7]))];
-      let e17_0 = [u8_xor(b17_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[0])), b19_0[0])), u8_xor(b17_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[1])), b19_0[1])), u8_xor(b17_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[2])), b19_0[2])), u8_xor(b17_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[3])), b19_0[3])), u8_xor(b17_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[4])), b19_0[4])), u8_xor(b17_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[5])), b19_0[5])), u8_xor(b17_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[6])), b19_0[6])), u8_xor(b17_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b18_0[7])), b19_0[7]))];
-      let e18_0 = [u8_xor(b18_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[0])), b15_0[0])), u8_xor(b18_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[1])), b15_0[1])), u8_xor(b18_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[2])), b15_0[2])), u8_xor(b18_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[3])), b15_0[3])), u8_xor(b18_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[4])), b15_0[4])), u8_xor(b18_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[5])), b15_0[5])), u8_xor(b18_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[6])), b15_0[6])), u8_xor(b18_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b19_0[7])), b15_0[7]))];
-      let e19_0 = [u8_xor(b19_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[0])), b16_0[0])), u8_xor(b19_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[1])), b16_0[1])), u8_xor(b19_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[2])), b16_0[2])), u8_xor(b19_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[3])), b16_0[3])), u8_xor(b19_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[4])), b16_0[4])), u8_xor(b19_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[5])), b16_0[5])), u8_xor(b19_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[6])), b16_0[6])), u8_xor(b19_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b15_0[7])), b16_0[7]))];
-      let e20_0 = [u8_xor(b20_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[0])), b22_0[0])), u8_xor(b20_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[1])), b22_0[1])), u8_xor(b20_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[2])), b22_0[2])), u8_xor(b20_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[3])), b22_0[3])), u8_xor(b20_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[4])), b22_0[4])), u8_xor(b20_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[5])), b22_0[5])), u8_xor(b20_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[6])), b22_0[6])), u8_xor(b20_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b21_0[7])), b22_0[7]))];
-      let e21_0 = [u8_xor(b21_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[0])), b23_0[0])), u8_xor(b21_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[1])), b23_0[1])), u8_xor(b21_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[2])), b23_0[2])), u8_xor(b21_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[3])), b23_0[3])), u8_xor(b21_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[4])), b23_0[4])), u8_xor(b21_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[5])), b23_0[5])), u8_xor(b21_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[6])), b23_0[6])), u8_xor(b21_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b22_0[7])), b23_0[7]))];
-      let e22_0 = [u8_xor(b22_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[0])), b24_0[0])), u8_xor(b22_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[1])), b24_0[1])), u8_xor(b22_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[2])), b24_0[2])), u8_xor(b22_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[3])), b24_0[3])), u8_xor(b22_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[4])), b24_0[4])), u8_xor(b22_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[5])), b24_0[5])), u8_xor(b22_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[6])), b24_0[6])), u8_xor(b22_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b23_0[7])), b24_0[7]))];
-      let e23_0 = [u8_xor(b23_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[0])), b20_0[0])), u8_xor(b23_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[1])), b20_0[1])), u8_xor(b23_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[2])), b20_0[2])), u8_xor(b23_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[3])), b20_0[3])), u8_xor(b23_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[4])), b20_0[4])), u8_xor(b23_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[5])), b20_0[5])), u8_xor(b23_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[6])), b20_0[6])), u8_xor(b23_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b24_0[7])), b20_0[7]))];
-      let e24_0 = [u8_xor(b24_0[0], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[0])), b21_0[0])), u8_xor(b24_0[1], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[1])), b21_0[1])), u8_xor(b24_0[2], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[2])), b21_0[2])), u8_xor(b24_0[3], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[3])), b21_0[3])), u8_xor(b24_0[4], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[4])), b21_0[4])), u8_xor(b24_0[5], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[5])), b21_0[5])), u8_xor(b24_0[6], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[6])), b21_0[6])), u8_xor(b24_0[7], u8_and(u8_from_field_unsafe(255 - to_field(b20_0[7])), b21_0[7]))];
-      -- round 0: iota
-      let f0_0 = [u8_xor(e0_0[0], rc0[0]), u8_xor(e0_0[1], rc0[1]), u8_xor(e0_0[2], rc0[2]), u8_xor(e0_0[3], rc0[3]), u8_xor(e0_0[4], rc0[4]), u8_xor(e0_0[5], rc0[5]), u8_xor(e0_0[6], rc0[6]), u8_xor(e0_0[7], rc0[7])];
-      let s1 = [f0_0, e1_0, e2_0, e3_0, e4_0, e5_0, e6_0, e7_0, e8_0, e9_0, e10_0, e11_0, e12_0, e13_0, e14_0, e15_0, e16_0, e17_0, e18_0, e19_0, e20_0, e21_0, e22_0, e23_0, e24_0];
-      s1
+  fn keccak_round(s: [[U8; 8]; 25], rc: [U8; 8]) -> [[U8; 8]; 25] {
+    -- theta: column parities, then D[x] = C[x-1] ^ rotl1(C[x+1]).
+    let c0 = @xor8(s[20], @xor8(s[15], @xor8(s[10], @xor8(s[5], s[0]))));
+    let c1 = @xor8(s[21], @xor8(s[16], @xor8(s[11], @xor8(s[6], s[1]))));
+    let c2 = @xor8(s[22], @xor8(s[17], @xor8(s[12], @xor8(s[7], s[2]))));
+    let c3 = @xor8(s[23], @xor8(s[18], @xor8(s[13], @xor8(s[8], s[3]))));
+    let c4 = @xor8(s[24], @xor8(s[19], @xor8(s[14], @xor8(s[9], s[4]))));
+    let d0 = @xor8(c4, @rotl1(c1));
+    let d1 = @xor8(c0, @rotl1(c2));
+    let d2 = @xor8(c1, @rotl1(c3));
+    let d3 = @xor8(c2, @rotl1(c4));
+    let d4 = @xor8(c3, @rotl1(c0));
+    let t0 = @xor8(s[0], d0);
+    let t1 = @xor8(s[1], d1);
+    let t2 = @xor8(s[2], d2);
+    let t3 = @xor8(s[3], d3);
+    let t4 = @xor8(s[4], d4);
+    let t5 = @xor8(s[5], d0);
+    let t6 = @xor8(s[6], d1);
+    let t7 = @xor8(s[7], d2);
+    let t8 = @xor8(s[8], d3);
+    let t9 = @xor8(s[9], d4);
+    let t10 = @xor8(s[10], d0);
+    let t11 = @xor8(s[11], d1);
+    let t12 = @xor8(s[12], d2);
+    let t13 = @xor8(s[13], d3);
+    let t14 = @xor8(s[14], d4);
+    let t15 = @xor8(s[15], d0);
+    let t16 = @xor8(s[16], d1);
+    let t17 = @xor8(s[17], d2);
+    let t18 = @xor8(s[18], d3);
+    let t19 = @xor8(s[19], d4);
+    let t20 = @xor8(s[20], d0);
+    let t21 = @xor8(s[21], d1);
+    let t22 = @xor8(s[22], d2);
+    let t23 = @xor8(s[23], d3);
+    let t24 = @xor8(s[24], d4);
+    -- rho + pi: b[pi(src)] = rotl(t[src], rho(src)).
+    let b0 = t0;
+    let b10 = @rotl_1(t1);
+    let b20 = @rotl_62(t2);
+    let b5 = @rotl_28(t3);
+    let b15 = @rotl_27(t4);
+    let b16 = @rotl_36(t5);
+    let b1 = @rotl_44(t6);
+    let b11 = @rotl_6(t7);
+    let b21 = @rotl_55(t8);
+    let b6 = @rotl_20(t9);
+    let b7 = @rotl_3(t10);
+    let b17 = @rotl_10(t11);
+    let b2 = @rotl_43(t12);
+    let b12 = @rotl_25(t13);
+    let b22 = @rotl_39(t14);
+    let b23 = @rotl_41(t15);
+    let b8 = @rotl_45(t16);
+    let b18 = @rotl_15(t17);
+    let b3 = @rotl_21(t18);
+    let b13 = @rotl_8(t19);
+    let b14 = @rotl_18(t20);
+    let b24 = @rotl_2(t21);
+    let b9 = @rotl_61(t22);
+    let b19 = @rotl_56(t23);
+    let b4 = @rotl_14(t24);
+    -- chi.
+    let e0 = @chi_lane(b0, b1, b2);
+    let e1 = @chi_lane(b1, b2, b3);
+    let e2 = @chi_lane(b2, b3, b4);
+    let e3 = @chi_lane(b3, b4, b0);
+    let e4 = @chi_lane(b4, b0, b1);
+    let e5 = @chi_lane(b5, b6, b7);
+    let e6 = @chi_lane(b6, b7, b8);
+    let e7 = @chi_lane(b7, b8, b9);
+    let e8 = @chi_lane(b8, b9, b5);
+    let e9 = @chi_lane(b9, b5, b6);
+    let e10 = @chi_lane(b10, b11, b12);
+    let e11 = @chi_lane(b11, b12, b13);
+    let e12 = @chi_lane(b12, b13, b14);
+    let e13 = @chi_lane(b13, b14, b10);
+    let e14 = @chi_lane(b14, b10, b11);
+    let e15 = @chi_lane(b15, b16, b17);
+    let e16 = @chi_lane(b16, b17, b18);
+    let e17 = @chi_lane(b17, b18, b19);
+    let e18 = @chi_lane(b18, b19, b15);
+    let e19 = @chi_lane(b19, b15, b16);
+    let e20 = @chi_lane(b20, b21, b22);
+    let e21 = @chi_lane(b21, b22, b23);
+    let e22 = @chi_lane(b22, b23, b24);
+    let e23 = @chi_lane(b23, b24, b20);
+    let e24 = @chi_lane(b24, b20, b21);
+    -- iota.
+    let f0 = @xor8(e0, rc);
+    [f0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24]
   }
 ⟧
 

From 8d82502c90011de5055514aff4931dc47506273e Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sun, 12 Jul 2026 19:13:01 -0700
Subject: [PATCH 15/22] keccak: call keccak_round instead of inlining all 24
 rounds

Inlining the 24 rounds collapsed keccak_f into one 89,678-column circuit
(a pathological trace width: heavy to commit and to native-compile).
Calling keccak_round shares one ~3942-wide circuit across the rounds (24
rows per permutation), keeping the theta/rho/chi/iota helpers inlined
within it -- the same granularity as blake3's g_function.

keccak_f 89,678 -> 5,054 wide; total committed width ~90k -> 10,604 (8.5x
smaller proof / trace). The FFT-cost proxy rises (6,723,868 -> 14,303,230)
because it over-weights the taller trace's log-height factor, but real
proving is faster: keccak256_bench average throughput 5.11 -> 5.56 KiB/s
(+8.8%). Digests verified against the Rust reference across rate-boundary
sizes.
---
 Ix/IxVM/Keccak.lean | 48 ++++++++++++++++++++++-----------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/Ix/IxVM/Keccak.lean b/Ix/IxVM/Keccak.lean
index 9ea7f17c..4649f7ea 100644
--- a/Ix/IxVM/Keccak.lean
+++ b/Ix/IxVM/Keccak.lean
@@ -594,30 +594,30 @@ def keccak := ⟦
      24 share one circuit (one row per permutation). -/
 
   fn keccak_f(s: [[U8; 8]; 25]) -> [[U8; 8]; 25] {
-    let s = @keccak_round(s, [0x01u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = @keccak_round(s, [0x82u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = @keccak_round(s, [0x8au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = @keccak_round(s, [0u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = @keccak_round(s, [0x8bu8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = @keccak_round(s, [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = @keccak_round(s, [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = @keccak_round(s, [0x09u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = @keccak_round(s, [0x8au8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = @keccak_round(s, [0x88u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = @keccak_round(s, [0x09u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = @keccak_round(s, [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = @keccak_round(s, [0x8bu8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = @keccak_round(s, [0x8bu8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = @keccak_round(s, [0x89u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = @keccak_round(s, [0x03u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = @keccak_round(s, [0x02u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = @keccak_round(s, [0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = @keccak_round(s, [0x0au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = @keccak_round(s, [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = @keccak_round(s, [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = @keccak_round(s, [0x80u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = @keccak_round(s, [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    @keccak_round(s, [0x08u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8])
+    let s = keccak_round(s, [0x01u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_round(s, [0x82u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_round(s, [0x8au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_round(s, [0u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_round(s, [0x8bu8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_round(s, [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_round(s, [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_round(s, [0x09u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_round(s, [0x8au8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_round(s, [0x88u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_round(s, [0x09u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_round(s, [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_round(s, [0x8bu8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_round(s, [0x8bu8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_round(s, [0x89u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_round(s, [0x03u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_round(s, [0x02u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_round(s, [0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_round(s, [0x0au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let s = keccak_round(s, [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_round(s, [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_round(s, [0x80u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
+    let s = keccak_round(s, [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
+    keccak_round(s, [0x08u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8])
   }
 
   fn keccak_round(s: [[U8; 8]; 25], rc: [U8; 8]) -> [[U8; 8]; 25] {

From a230a8878de08da32dd49951a3af461d5d900a92 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sat, 11 Jul 2026 15:59:05 -0700
Subject: [PATCH 16/22] Aiur blake3: extract G-function word-ops into @-inlined
 helpers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

blake3_g_function was ~100 lines of inlined byte arithmetic: six
little-endian carry chains, the add/xor/rotate quarter-round steps
spelled out per byte. Factor into `@`-inlined helpers — u32_le_add,
u32_xor, and the four right-rotations rotr16/rotr8 (byte moves) and
rotr12/rotr7 (byte move + chained gadget) — leaving the G function as
its eight-step dataflow. Still one circuit, byte-identical work.

Probe (1 hash, 2048 bytes, non-periodic LCG): 6,575,392 FFT,
unchanged. `aiur-hashes` blake3 cases green (execute/claim/prove-verify).
---
 Ix/IxVM/Blake3.lean | 152 +++++++++++++++-----------------------------
 1 file changed, 50 insertions(+), 102 deletions(-)

diff --git a/Ix/IxVM/Blake3.lean b/Ix/IxVM/Blake3.lean
index 7c1061c2..cc173374 100644
--- a/Ix/IxVM/Blake3.lean
+++ b/Ix/IxVM/Blake3.lean
@@ -292,6 +292,48 @@ def blake3 := ⟦
     }
   }
 
+  /- # Word-op helpers for the G function (all `@`-inlined). -/
+
+  -- Little-endian 32-bit add (index 0 = LSB); mutually-exclusive carries
+  -- fold with a free field `+`.
+  fn u32_le_add(a: [U8; 4], b: [U8; 4]) -> [U8; 4] {
+    let (s0, c1) = u8_add(a[0], b[0]);
+    let (t1, o1) = u8_add(a[1], b[1]);
+    let (s1, c1a) = u8_add(t1, c1);
+    let c2 = u8_from_field_unsafe(to_field(o1) + to_field(c1a));
+    let (t2, o2) = u8_add(a[2], b[2]);
+    let (s2, c2a) = u8_add(t2, c2);
+    let c3 = u8_from_field_unsafe(to_field(o2) + to_field(c2a));
+    let (t3, _z) = u8_add(a[3], b[3]);
+    let (s3, _z) = u8_add(t3, c3);
+    [s0, s1, s2, s3]
+  }
+
+  fn u32_xor(a: [U8; 4], b: [U8; 4]) -> [U8; 4] {
+    [u8_xor(a[0], b[0]), u8_xor(a[1], b[1]), u8_xor(a[2], b[2]), u8_xor(a[3], b[3])]
+  }
+
+  -- Right-rotations of a little-endian word. rotr16 / rotr8 are pure byte
+  -- moves (free); rotr12 / rotr7 are a byte move composed with the chained
+  -- 4-/7-bit gadget (two lookups + two free field adds each).
+  fn rotr16(w: [U8; 4]) -> [U8; 4] { [w[2], w[3], w[0], w[1]] }
+
+  fn rotr8(w: [U8; 4]) -> [U8; 4] { [w[1], w[2], w[3], w[0]] }
+
+  fn rotr12(w: [U8; 4]) -> [U8; 4] {
+    let (e0, e1, e2) = u8_chain_rotr4(w[1], w[2]);
+    let (f0, f1, f2) = u8_chain_rotr4(w[3], w[0]);
+    [e0, u8_from_field_unsafe(to_field(e1) + to_field(f2)), f0,
+     u8_from_field_unsafe(to_field(f1) + to_field(e2))]
+  }
+
+  fn rotr7(w: [U8; 4]) -> [U8; 4] {
+    let (g0, g1, g2) = u8_chain_rotr7(w[0], w[1]);
+    let (h0, h1, h2) = u8_chain_rotr7(w[2], w[3]);
+    [g0, u8_from_field_unsafe(to_field(g1) + to_field(h2)), h0,
+     u8_from_field_unsafe(to_field(h1) + to_field(g2))]
+  }
+
   fn blake3_g_function(
     a: [U8; 4],
     b: [U8; 4],
@@ -300,108 +342,14 @@ def blake3 := ⟦
     x: [U8; 4],
     y: [U8; 4]
   ) -> [[U8; 4]; 4] {
-    -- a = (a + b) + x
-    let (r1_0, r1_c1) = u8_add(a[0], b[0]);
-    let (r1_s1, r1_o1) = u8_add(a[1], b[1]);
-    let (r1_1, r1_c1a) = u8_add(r1_s1, r1_c1);
-    let r1_c2 = u8_from_field_unsafe(to_field(r1_o1) + to_field(r1_c1a));
-    let (r1_s2, r1_o2) = u8_add(a[2], b[2]);
-    let (r1_2, r1_c2a) = u8_add(r1_s2, r1_c2);
-    let r1_c3 = u8_from_field_unsafe(to_field(r1_o2) + to_field(r1_c2a));
-    let (r1_s3, _z) = u8_add(a[3], b[3]);
-    let (r1_3, _z) = u8_add(r1_s3, r1_c3);
-    let (a0, r2_c1) = u8_add(r1_0, x[0]);
-    let (r2_s1, r2_o1) = u8_add(r1_1, x[1]);
-    let (a1, r2_c1a) = u8_add(r2_s1, r2_c1);
-    let r2_c2 = u8_from_field_unsafe(to_field(r2_o1) + to_field(r2_c1a));
-    let (r2_s2, r2_o2) = u8_add(r1_2, x[2]);
-    let (a2, r2_c2a) = u8_add(r2_s2, r2_c2);
-    let r2_c3 = u8_from_field_unsafe(to_field(r2_o2) + to_field(r2_c2a));
-    let (r2_s3, _z) = u8_add(r1_3, x[3]);
-    let (a3, _z) = u8_add(r2_s3, r2_c3);
-    let a = [a0, a1, a2, a3];
-
-    let d0 = u8_xor(d[0], a[0]);
-    let d1 = u8_xor(d[1], a[1]);
-    let d2 = u8_xor(d[2], a[2]);
-    let d3 = u8_xor(d[3], a[3]);
-    let d = [d2, d3, d0, d1]; -- Right-rotated 16
-
-    -- c = c + d
-    let (nc0, r3_c1) = u8_add(c[0], d[0]);
-    let (r3_s1, r3_o1) = u8_add(c[1], d[1]);
-    let (nc1, r3_c1a) = u8_add(r3_s1, r3_c1);
-    let r3_c2 = u8_from_field_unsafe(to_field(r3_o1) + to_field(r3_c1a));
-    let (r3_s2, r3_o2) = u8_add(c[2], d[2]);
-    let (nc2, r3_c2a) = u8_add(r3_s2, r3_c2);
-    let r3_c3 = u8_from_field_unsafe(to_field(r3_o2) + to_field(r3_c2a));
-    let (r3_s3, _z) = u8_add(c[3], d[3]);
-    let (nc3, _z) = u8_add(r3_s3, r3_c3);
-    let c = [nc0, nc1, nc2, nc3];
-
-    let b0 = u8_xor(b[0], c[0]);
-    let b1 = u8_xor(b[1], c[1]);
-    let b2 = u8_xor(b[2], c[2]);
-    let b3 = u8_xor(b[3], c[3]);
-    -- Right-rotated 12 = rotr8 (byte move) ∘ rotr4 (chained gadget).
-    -- rotr8 of [b0,b1,b2,b3] is [b1,b2,b3,b0]; rotr4 over that pairs (b1,b2)
-    -- and (b3,b0). Two gadget lookups + two free field adds.
-    let (e0, e1, e2) = u8_chain_rotr4(b1, b2);
-    let (f0, f1, f2) = u8_chain_rotr4(b3, b0);
-    -- Combined parts occupy disjoint bit positions: sum is a byte, add as `G`.
-    let b = [e0, u8_from_field_unsafe(to_field(e1) + to_field(f2)), f0,
-             u8_from_field_unsafe(to_field(f1) + to_field(e2))]; -- Right-rotated 12
-
-    -- a = (a + b) + y
-    let (r4_0, r4_c1) = u8_add(a[0], b[0]);
-    let (r4_s1, r4_o1) = u8_add(a[1], b[1]);
-    let (r4_1, r4_c1a) = u8_add(r4_s1, r4_c1);
-    let r4_c2 = u8_from_field_unsafe(to_field(r4_o1) + to_field(r4_c1a));
-    let (r4_s2, r4_o2) = u8_add(a[2], b[2]);
-    let (r4_2, r4_c2a) = u8_add(r4_s2, r4_c2);
-    let r4_c3 = u8_from_field_unsafe(to_field(r4_o2) + to_field(r4_c2a));
-    let (r4_s3, _z) = u8_add(a[3], b[3]);
-    let (r4_3, _z) = u8_add(r4_s3, r4_c3);
-    let (a0, r5_c1) = u8_add(r4_0, y[0]);
-    let (r5_s1, r5_o1) = u8_add(r4_1, y[1]);
-    let (a1, r5_c1a) = u8_add(r5_s1, r5_c1);
-    let r5_c2 = u8_from_field_unsafe(to_field(r5_o1) + to_field(r5_c1a));
-    let (r5_s2, r5_o2) = u8_add(r4_2, y[2]);
-    let (a2, r5_c2a) = u8_add(r5_s2, r5_c2);
-    let r5_c3 = u8_from_field_unsafe(to_field(r5_o2) + to_field(r5_c2a));
-    let (r5_s3, _z) = u8_add(r4_3, y[3]);
-    let (a3, _z) = u8_add(r5_s3, r5_c3);
-    let a = [a0, a1, a2, a3];
-
-    let d0 = u8_xor(d[0], a[0]);
-    let d1 = u8_xor(d[1], a[1]);
-    let d2 = u8_xor(d[2], a[2]);
-    let d3 = u8_xor(d[3], a[3]);
-    let d = [d1, d2, d3, d0]; -- Right-rotated 8
-
-    -- c = c + d
-    let (nc0, r6_c1) = u8_add(c[0], d[0]);
-    let (r6_s1, r6_o1) = u8_add(c[1], d[1]);
-    let (nc1, r6_c1a) = u8_add(r6_s1, r6_c1);
-    let r6_c2 = u8_from_field_unsafe(to_field(r6_o1) + to_field(r6_c1a));
-    let (r6_s2, r6_o2) = u8_add(c[2], d[2]);
-    let (nc2, r6_c2a) = u8_add(r6_s2, r6_c2);
-    let r6_c3 = u8_from_field_unsafe(to_field(r6_o2) + to_field(r6_c2a));
-    let (r6_s3, _z) = u8_add(c[3], d[3]);
-    let (nc3, _z) = u8_add(r6_s3, r6_c3);
-    let c = [nc0, nc1, nc2, nc3];
-
-    let b0 = u8_xor(b[0], c[0]);
-    let b1 = u8_xor(b[1], c[1]);
-    let b2 = u8_xor(b[2], c[2]);
-    let b3 = u8_xor(b[3], c[3]);
-    -- Right-rotated 7 via the chained gadget: pairs (b0,b1) and (b2,b3),
-    -- two lookups + two free field adds.
-    let (g0, g1, g2) = u8_chain_rotr7(b0, b1);
-    let (h0, h1, h2) = u8_chain_rotr7(b2, b3);
-    let b = [g0, u8_from_field_unsafe(to_field(g1) + to_field(h2)), h0,
-             u8_from_field_unsafe(to_field(h1) + to_field(g2))]; -- Right-rotated 7
-
+    let a = @u32_le_add(@u32_le_add(a, b), x);
+    let d = @rotr16(@u32_xor(d, a));
+    let c = @u32_le_add(c, d);
+    let b = @rotr12(@u32_xor(b, c));
+    let a = @u32_le_add(@u32_le_add(a, b), y);
+    let d = @rotr8(@u32_xor(d, a));
+    let c = @u32_le_add(c, d);
+    let b = @rotr7(@u32_xor(b, c));
     [a, b, c, d]
   }
 

From 739ff193cc0e4dd7e7b387030ffad27a25919cb4 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Sun, 12 Jul 2026 18:03:20 -0700
Subject: [PATCH 17/22] blake3: fuse the g-function's 3-word adds into one
 carry pass

Each `blake3_g_function` does two 3-word additions (a + b + x and
a + b + y) as chained `u32_le_add`s. `u32_le_add3` accumulates each byte
column with chained `u8_add` and folds the 0/1 carry bits with a free
field add: 11 u8_adds vs 14 for two chained adds. Column carry is
floor(sum/256) <= 2.

blake3_g_function lookups 63 -> 57, width 224 -> 206; blake3_bench total
FFT 6,575,392 -> 6,214,420 (-5.5%). Digests verified against the Rust
reference across chunk/block-boundary sizes.
---
 Ix/IxVM/Blake3.lean | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/Ix/IxVM/Blake3.lean b/Ix/IxVM/Blake3.lean
index cc173374..a7d87bff 100644
--- a/Ix/IxVM/Blake3.lean
+++ b/Ix/IxVM/Blake3.lean
@@ -309,6 +309,29 @@ def blake3 := ⟦
     [s0, s1, s2, s3]
   }
 
+  -- Little-endian sum of three 32-bit words in one carry-propagation pass:
+  -- each byte column accumulates with chained `u8_add` (running partial stays
+  -- < 256) and the 0/1 carry bits fold into the next column with a free field
+  -- add. 11 `u8_add`s vs 14 for two chained `u32_le_add`s. Column carry is
+  -- floor(column_sum / 256) <= 2 (< 256), safe to feed back to `u8_add`.
+  fn u32_le_add3(a: [U8; 4], b: [U8; 4], c: [U8; 4]) -> [U8; 4] {
+    let (t, k1) = u8_add(a[0], b[0]);
+    let (s0, k2) = u8_add(t, c[0]);
+    let cy = u8_from_field_unsafe(to_field(k1) + to_field(k2));
+    let (t, k1) = u8_add(a[1], b[1]);
+    let (t, k2) = u8_add(t, c[1]);
+    let (s1, k3) = u8_add(t, cy);
+    let cy = u8_from_field_unsafe(to_field(k1) + to_field(k2) + to_field(k3));
+    let (t, k1) = u8_add(a[2], b[2]);
+    let (t, k2) = u8_add(t, c[2]);
+    let (s2, k3) = u8_add(t, cy);
+    let cy = u8_from_field_unsafe(to_field(k1) + to_field(k2) + to_field(k3));
+    let (t, _z) = u8_add(a[3], b[3]);
+    let (t, _z) = u8_add(t, c[3]);
+    let (s3, _z) = u8_add(t, cy);
+    [s0, s1, s2, s3]
+  }
+
   fn u32_xor(a: [U8; 4], b: [U8; 4]) -> [U8; 4] {
     [u8_xor(a[0], b[0]), u8_xor(a[1], b[1]), u8_xor(a[2], b[2]), u8_xor(a[3], b[3])]
   }
@@ -342,11 +365,11 @@ def blake3 := ⟦
     x: [U8; 4],
     y: [U8; 4]
   ) -> [[U8; 4]; 4] {
-    let a = @u32_le_add(@u32_le_add(a, b), x);
+    let a = @u32_le_add3(a, b, x);
     let d = @rotr16(@u32_xor(d, a));
     let c = @u32_le_add(c, d);
     let b = @rotr12(@u32_xor(b, c));
-    let a = @u32_le_add(@u32_le_add(a, b), y);
+    let a = @u32_le_add3(a, b, y);
     let d = @rotr8(@u32_xor(d, a));
     let c = @u32_le_add(c, d);
     let b = @rotr7(@u32_xor(b, c));

From 5fccf536b376b38c83f99635ae1fc530d8c4c565 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Mon, 13 Jul 2026 14:48:48 +0000
Subject: [PATCH 18/22] bench: shared hash-proving harness with circuit stats
 and a 512 KiB grid
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

All three hash benches (blake3, sha256, and the new bench-keccak) route
through Benchmarks/HashCommon.lean, which executes the largest workload
once and prints Aiur circuit statistics — per-circuit width, height and
FFT cost, plus the total circuit width — before the timed proving runs,
so width regressions show up directly in benchmark output.

Input data is LCG-seeded and non-periodic: an `(i + idx) % 256` pattern
repeats every 256 bytes, so repeated schedule/compression/permutation
sub-computations memoize across blocks and understate honest proving
cost (sha256's per-word schedule circuit reported 240 unique rows where
honest data produces 1584).

The grid is 4K/32K/128K bytes x 1/4 hashes: the 512 KiB max case sits
on the sustained bytes/s plateau (reached at ~128 KiB per proof) while
keeping a full run fast enough to iterate on.
---
 Benchmarks/Blake3.lean     | 46 +---------------------
 Benchmarks/HashCommon.lean | 80 ++++++++++++++++++++++++++++++++++++++
 Benchmarks/Keccak.lean     | 12 ++++++
 Benchmarks/Sha256.lean     | 46 +---------------------
 lakefile.lean              |  8 ++++
 5 files changed, 104 insertions(+), 88 deletions(-)
 create mode 100644 Benchmarks/HashCommon.lean
 create mode 100644 Benchmarks/Keccak.lean

diff --git a/Benchmarks/Blake3.lean b/Benchmarks/Blake3.lean
index d8d04772..a24c0946 100644
--- a/Benchmarks/Blake3.lean
+++ b/Benchmarks/Blake3.lean
@@ -1,54 +1,12 @@
 import Ix.IxVM.Core
 import Ix.IxVM.ByteStream
 import Ix.IxVM.Blake3
-import Ix.Aiur.Protocol
-import Ix.Aiur.Compiler
-import Ix.Benchmark.Bench
-
-open BgroupM
-
-abbrev dataSizes := #[64, 128, 256, 512, 1024, 2048]
-abbrev numHashesPerProof := #[1, 2, 4, 8, 16, 32]
-
-def commitmentParameters : Aiur.CommitmentParameters := {
-  logBlowup := 1
-  capHeight := 0
-}
-
-def friParameters : Aiur.FriParameters := {
-  logFinalPolyLen := 0
-  maxLogArity := 1
-  numQueries := 100
-  commitProofOfWorkBits := 20
-  queryProofOfWorkBits := 0
-}
+import Benchmarks.HashCommon
 
 def mergedToplevel : Except Aiur.Global Aiur.Source.Toplevel := do
   let tl ← IxVM.core.merge IxVM.byteStream
   tl.merge IxVM.blake3
 
-def blake3Bench : IO $ Array BenchReport := do
-  let .ok toplevel := mergedToplevel
-    | throw (IO.userError "Merging failed")
-  let .ok compiled := toplevel.compile
-    | throw (IO.userError "Compilation failed")
-  let some funIdx := compiled.getFuncIdx `blake3_bench
-    | throw (IO.userError "Aiur function not found")
-  let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters
-  bgroup "prove blake3" { oneShot := true, avgThroughput := true, report := true } do
-    for dataSize in dataSizes do
-      for numHashes in numHashesPerProof do
-        let ioBuffer := Array.range numHashes |>.foldl
-          (init := default)
-          fun ioBuffer idx =>
-            let data := Array.range dataSize |>.map
-              -- Add `idx` so every preimage is different and avoids memoization.
-              fun i => Aiur.G.ofUInt8 (i + idx).toUInt8
-            ioBuffer.extend 0 #[.ofNat idx] data
-        throughput (.ElementsAndBytes numHashes.toUInt64 (dataSize * numHashes).toUInt64 "hashes")
-        bench s!"dataSize={dataSize} numHashes={numHashes}"
-          (aiurSystem.prove funIdx #[Aiur.G.ofNat numHashes]) ioBuffer
-
 def main : IO Unit := do
-  let _ ← blake3Bench
+  let _ ← HashBench.run "prove blake3" `blake3_bench mergedToplevel
   return
diff --git a/Benchmarks/HashCommon.lean b/Benchmarks/HashCommon.lean
new file mode 100644
index 00000000..1559cacd
--- /dev/null
+++ b/Benchmarks/HashCommon.lean
@@ -0,0 +1,80 @@
+import Ix.Aiur.Protocol
+import Ix.Aiur.Compiler
+import Ix.Aiur.Statistics
+import Ix.Benchmark.Bench
+
+/-!
+Shared harness for the hash-proving benchmarks (`bench-blake3`,
+`bench-sha256` and `bench-keccak`).
+
+Each benchmark case proves `numHashes` hashes of `dataSize` bytes in a single
+Aiur proof and reports proving throughput in bytes/s. Before the timed runs,
+the harness executes the largest workload once (execution only, no proving)
+and prints the circuit statistics — per-circuit width, height and FFT cost,
+plus the total circuit width — so width regressions show up in the benchmark
+output.
+-/
+
+open BgroupM
+
+namespace HashBench
+
+/-- Sizes in bytes of each hashed message. The largest case proves 4 hashes
+of 128 KiB — 512 KiB per proof — which sits on the sustained bytes/s plateau
+(reached at ~128 KiB per proof) while keeping a full grid run fast enough to
+iterate on. -/
+def dataSizes : Array Nat := #[4096, 32768, 131072]
+
+/-- Number of hashes proven in a single proof. -/
+def numHashesPerProof : Array Nat := #[1, 4]
+
+def commitmentParameters : Aiur.CommitmentParameters := {
+  logBlowup := 1
+  capHeight := 0
+}
+
+def friParameters : Aiur.FriParameters := {
+  logFinalPolyLen := 0
+  maxLogArity := 1
+  numQueries := 100
+  commitProofOfWorkBits := 20
+  queryProofOfWorkBits := 0
+}
+
+/-- Builds an `IOBuffer` with `numHashes` streams of `dataSize` bytes each.
+
+The bytes are non-periodic pseudorandom (LCG), seeded per hash: a
+`(i + idx) % 256` pattern repeats every 256 bytes, which memoizes repeated
+sub-computations across blocks and understates honest proving cost. -/
+def mkIOBuffer (dataSize numHashes : Nat) : Aiur.IOBuffer :=
+  Array.range numHashes |>.foldl (init := default) fun ioBuffer idx =>
+    let data := Array.range dataSize |>.map fun i =>
+      Aiur.G.ofUInt8 (((i + idx * dataSize) * 1103515245 + 12345) >>> 16).toUInt8
+    ioBuffer.extend 0 #[.ofNat idx] data
+
+def run (groupName : String) (funcName : Lean.Name)
+    (toplevel : Except Aiur.Global Aiur.Source.Toplevel) : IO (Array BenchReport) := do
+  let .ok toplevel := toplevel
+    | throw (IO.userError "Merging failed")
+  let .ok compiled := toplevel.compile
+    | throw (IO.userError "Compilation failed")
+  let some funIdx := compiled.getFuncIdx funcName
+    | throw (IO.userError "Aiur function not found")
+  let maxDataSize := dataSizes.foldl Nat.max 0
+  let maxNumHashes := numHashesPerProof.foldl Nat.max 0
+  match compiled.bytecode.execute funIdx #[.ofNat maxNumHashes]
+      (mkIOBuffer maxDataSize maxNumHashes) with
+  | .error e => throw (IO.userError s!"Execution failed: {e}")
+  | .ok (_, _, queryCounts) =>
+    IO.println s!"Circuit statistics at dataSize={maxDataSize} numHashes={maxNumHashes}:"
+    Aiur.printStats (Aiur.computeStats compiled queryCounts)
+  let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters
+  bgroup groupName { oneShot := true, avgThroughput := true, report := true } do
+    for dataSize in dataSizes do
+      for numHashes in numHashesPerProof do
+        let ioBuffer := mkIOBuffer dataSize numHashes
+        throughput (.ElementsAndBytes numHashes.toUInt64 (dataSize * numHashes).toUInt64 "hashes")
+        bench s!"dataSize={dataSize} numHashes={numHashes}"
+          (aiurSystem.prove funIdx #[Aiur.G.ofNat numHashes]) ioBuffer
+
+end HashBench
diff --git a/Benchmarks/Keccak.lean b/Benchmarks/Keccak.lean
new file mode 100644
index 00000000..726ee7ea
--- /dev/null
+++ b/Benchmarks/Keccak.lean
@@ -0,0 +1,12 @@
+import Ix.IxVM.Core
+import Ix.IxVM.ByteStream
+import Ix.IxVM.Keccak
+import Benchmarks.HashCommon
+
+def mergedToplevel : Except Aiur.Global Aiur.Source.Toplevel := do
+  let tl ← IxVM.core.merge IxVM.byteStream
+  tl.merge IxVM.keccak
+
+def main : IO Unit := do
+  let _ ← HashBench.run "prove keccak256" `keccak256_bench mergedToplevel
+  return
diff --git a/Benchmarks/Sha256.lean b/Benchmarks/Sha256.lean
index 96c780d4..cc15cfd9 100644
--- a/Benchmarks/Sha256.lean
+++ b/Benchmarks/Sha256.lean
@@ -1,54 +1,12 @@
 import Ix.IxVM.Core
 import Ix.IxVM.ByteStream
 import Ix.IxVM.Sha256
-import Ix.Aiur.Protocol
-import Ix.Aiur.Compiler
-import Ix.Benchmark.Bench
-
-open BgroupM
-
-abbrev dataSizes := #[64, 128, 256, 512, 1024, 2048]
-abbrev numHashesPerProof := #[1, 2, 4, 8, 16, 32]
-
-def commitmentParameters : Aiur.CommitmentParameters := {
-  logBlowup := 1
-  capHeight := 0
-}
-
-def friParameters : Aiur.FriParameters := {
-  logFinalPolyLen := 0
-  maxLogArity := 1
-  numQueries := 100
-  commitProofOfWorkBits := 20
-  queryProofOfWorkBits := 0
-}
+import Benchmarks.HashCommon
 
 def mergedToplevel : Except Aiur.Global Aiur.Source.Toplevel := do
   let tl ← IxVM.core.merge IxVM.byteStream
   tl.merge IxVM.sha256
 
-def sha256Bench : IO $ Array BenchReport := do
-  let .ok toplevel := mergedToplevel
-    | throw (IO.userError "Merging failed")
-  let .ok compiled := toplevel.compile
-    | throw (IO.userError "Compilation failed")
-  let some funIdx := compiled.getFuncIdx `sha256_bench
-    | throw (IO.userError "Aiur function not found")
-  let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters
-  bgroup "prove sha256" { oneShot := true, avgThroughput := true, report := true } do
-    for dataSize in dataSizes do
-      for numHashes in numHashesPerProof do
-        let ioBuffer := Array.range numHashes |>.foldl
-          (init := default)
-          fun ioBuffer idx =>
-            let data := Array.range dataSize |>.map
-              -- Add `idx` so every preimage is different and avoids memoization.
-              fun i => Aiur.G.ofUInt8 (i + idx).toUInt8
-            ioBuffer.extend 0 #[.ofNat idx] data
-        throughput (.ElementsAndBytes numHashes.toUInt64 (dataSize * numHashes).toUInt64 "hashes")
-        bench s!"dataSize={dataSize} numHashes={numHashes}"
-          (aiurSystem.prove funIdx #[Aiur.G.ofNat numHashes]) ioBuffer
-
 def main : IO Unit := do
-  let _ ← sha256Bench
+  let _ ← HashBench.run "prove sha256" `sha256_bench mergedToplevel
   return
diff --git a/lakefile.lean b/lakefile.lean
index 8b9ee021..012cdcb3 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -98,6 +98,11 @@ end Tests
 
 section Benchmarks
 
+-- Shared harness for the hash-proving benchmarks; a `lean_lib` so the
+-- `bench-{blake3,sha256,keccak}` exe roots can import it.
+lean_lib BenchmarksHashCommon where
+  roots := #[`Benchmarks.HashCommon]
+
 lean_exe «bench-aiur» where
   root := `Benchmarks.Aiur
 
@@ -107,6 +112,9 @@ lean_exe «bench-blake3» where
 lean_exe «bench-sha256» where
   root := `Benchmarks.Sha256
 
+lean_exe «bench-keccak» where
+  root := `Benchmarks.Keccak
+
 lean_exe «bench-ixvm» where
   root := `Benchmarks.IxVM
   supportInterpreter := true

From 1a240b30d7449d95e11f34413be1fe8f98aa1f94 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Mon, 13 Jul 2026 13:58:49 +0000
Subject: [PATCH 19/22] aiur: correct memory circuit width in statistics (size
 + 7)

Mirrors crates/aiur/src/memory.rs: multiplicity + selector + pointer +
size value columns, plus one lookup -> 2*(1+1) stage-2 columns. The old
size + 11 over-counted every memory circuit by 4.
---
 Ix/Aiur/Statistics.lean | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Ix/Aiur/Statistics.lean b/Ix/Aiur/Statistics.lean
index ddcf082b..400f2252 100644
--- a/Ix/Aiur/Statistics.lean
+++ b/Ix/Aiur/Statistics.lean
@@ -58,7 +58,9 @@ def computeStats (compiled : CompiledToplevel) (queryCounts : Array QueryCount)
         acc := acc.push { name, width := w, height := h, cacheHits := hits, fftCost := fftCost w h : CircuitStats }
     acc
   let memoryCircuits := t.memorySizes.mapIdx fun i size =>
-    let w := size + 11
+    -- Mirrors `crates/aiur/src/memory.rs`: multiplicity + selector + pointer
+    -- + `size` value columns, plus one lookup -> 2*(1 + 1) stage-2 columns.
+    let w := size + 7
     let qc := queryCounts[nAllFuns + i]!
     let h := qc.uniqueRows
     let hits := qc.totalHits - qc.uniqueRows

From f896085c2e9175aef839c44142b2f022c90f13f3 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Mon, 13 Jul 2026 14:49:47 +0000
Subject: [PATCH 20/22] Aiur: generalize the chain-rotr gadget to any k in
 1..=7
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`u8_chain_rotr(k, hi, lo)` replaces the fixed chain_rotr7/chain_rotr4
byte-pair ops end to end: source syntax, the typed/simple/concrete
stages, bytecode (`Op.u8ChainRotr k`, FFI tag 24; the debug/range-check
/div-mod tags shift down by one), layout, codegen, and the three
evaluators. The Bytes2 table gains one preprocessed output triple,
multiplicity column and lookup per k (main 10 -> 15, preprocessed
16 -> 31 columns on the fixed 65536-row table); channels 13..19
address the seven rotation amounts. The codegen'd IxVM kernel keeps
compiling through legacy fixed-amount aliases until regenerated.

A chained pair costs 3 aux + 1 lookup regardless of k, so a 64-bit
lane rotation is 4 chain lookups plus free field adds for ANY bit
offset — the enabler for keccak's rho step, whose offsets hit every k.
---
 Ix/Aiur/Compiler/Check.lean         |  14 +-
 Ix/Aiur/Compiler/Concretize.lean    |  19 +-
 Ix/Aiur/Compiler/Layout.lean        |   2 +-
 Ix/Aiur/Compiler/Lower.lean         |   7 +-
 Ix/Aiur/Compiler/Match.lean         |   3 +-
 Ix/Aiur/Goldilocks.lean             |  16 +-
 Ix/Aiur/Interpret.lean              |  21 +-
 Ix/Aiur/Meta.lean                   |  17 +-
 Ix/Aiur/Semantics/BytecodeEval.lean |  15 +-
 Ix/Aiur/Semantics/SourceEval.lean   |  18 +-
 Ix/Aiur/Stages/Bytecode.lean        |   6 +-
 Ix/Aiur/Stages/Codegen.lean         |  24 ++-
 Ix/Aiur/Stages/Concrete.lean        |   8 +-
 Ix/Aiur/Stages/Simple.lean          |   8 +-
 Ix/Aiur/Stages/Source.lean          |  18 +-
 Ix/Aiur/Stages/Typed.lean           |   8 +-
 Ix/IxVM/Blake3.lean                 |   8 +-
 Tests/Aiur/Aiur.lean                |   8 +-
 Tests/Aiur/Cross.lean               |   8 +-
 crates/aiur/src/bytecode.rs         |   4 +-
 crates/aiur/src/constraints.rs      |  20 +-
 crates/aiur/src/execute.rs          |  32 +--
 crates/aiur/src/gadgets/bytes2.rs   | 305 +++++++++++-----------------
 crates/aiur/src/lib.rs              |  11 +-
 crates/aiur/src/trace.rs            |  25 +--
 crates/ffi/src/aiur/toplevel.rs     |  12 +-
 26 files changed, 258 insertions(+), 379 deletions(-)

diff --git a/Ix/Aiur/Compiler/Check.lean b/Ix/Aiur/Compiler/Check.lean
index 2066a8b4..787540c6 100644
--- a/Ix/Aiur/Compiler/Check.lean
+++ b/Ix/Aiur/Compiler/Check.lean
@@ -49,6 +49,7 @@ inductive CheckError
   | infiniteType : Nat → Typ → CheckError
   | unresolvedMVar : Nat → CheckError
   | u8LitOutOfRange : Nat → CheckError
+  | chainRotrOutOfRange : Nat → CheckError
   | entryHasPointer : Global → CheckError
   deriving Repr
 
@@ -765,14 +766,12 @@ def inferTerm (t : Term) : CheckM Typed.Term := match t with
     let a' ← checkNoEscape a .u8
     let b' ← checkNoEscape b .u8
     pure (Typed.Term.u8Mul (.tuple #[.u8, .u8]) false a' b')
-  | .u8ChainRotr7 a b => do
+  | .u8ChainRotr k a b => do
+    if k == 0 || k > 7 then
+      throw (.chainRotrOutOfRange k)
     let a' ← checkNoEscape a .u8
     let b' ← checkNoEscape b .u8
-    pure (Typed.Term.u8ChainRotr7 (.tuple #[.u8, .u8, .u8]) false a' b')
-  | .u8ChainRotr4 a b => do
-    let a' ← checkNoEscape a .u8
-    let b' ← checkNoEscape b .u8
-    pure (Typed.Term.u8ChainRotr4 (.tuple #[.u8, .u8, .u8]) false a' b')
+    pure (Typed.Term.u8ChainRotr k (.tuple #[.u8, .u8, .u8]) false a' b')
   | .u8Sub a b => do
     -- Low byte and the 0/1 borrow are both `u8` (same range argument as add).
     let a' ← checkNoEscape a .u8
@@ -968,8 +967,7 @@ def zonkTypedTerm (t : Typed.Term) : CheckM Typed.Term := match t with
   | .u8Xor τ e a b => do pure (.u8Xor (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b))
   | .u8Add τ e a b => do pure (.u8Add (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b))
   | .u8Mul τ e a b => do pure (.u8Mul (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b))
-  | .u8ChainRotr7 τ e a b => do pure (.u8ChainRotr7 (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b))
-  | .u8ChainRotr4 τ e a b => do pure (.u8ChainRotr4 (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b))
+  | .u8ChainRotr k τ e a b => do pure (.u8ChainRotr k (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b))
   | .u8Sub τ e a b => do pure (.u8Sub (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b))
   | .u8And τ e a b => do pure (.u8And (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b))
   | .u8Or τ e a b => do pure (.u8Or (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b))
diff --git a/Ix/Aiur/Compiler/Concretize.lean b/Ix/Aiur/Compiler/Concretize.lean
index 38934784..e6300b29 100644
--- a/Ix/Aiur/Compiler/Concretize.lean
+++ b/Ix/Aiur/Compiler/Concretize.lean
@@ -339,11 +339,8 @@ def termToConcrete
   | .u8Mul τ e a b => do
       pure (.u8Mul (← typToConcrete mono τ) e
                    (← termToConcrete mono a) (← termToConcrete mono b))
-  | .u8ChainRotr7 τ e a b => do
-      pure (.u8ChainRotr7 (← typToConcrete mono τ) e
-                   (← termToConcrete mono a) (← termToConcrete mono b))
-  | .u8ChainRotr4 τ e a b => do
-      pure (.u8ChainRotr4 (← typToConcrete mono τ) e
+  | .u8ChainRotr k τ e a b => do
+      pure (.u8ChainRotr k (← typToConcrete mono τ) e
                    (← termToConcrete mono a) (← termToConcrete mono b))
   | .u8Sub τ e a b => do
       pure (.u8Sub (← typToConcrete mono τ) e
@@ -557,9 +554,7 @@ def rewriteTypedTerm (decls : Typed.Decls)
       (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b)
   | .u8Mul τ e a b => .u8Mul (rewriteTyp subst mono τ) e
       (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b)
-  | .u8ChainRotr7 τ e a b => .u8ChainRotr7 (rewriteTyp subst mono τ) e
-      (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b)
-  | .u8ChainRotr4 τ e a b => .u8ChainRotr4 (rewriteTyp subst mono τ) e
+  | .u8ChainRotr k τ e a b => .u8ChainRotr k (rewriteTyp subst mono τ) e
       (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b)
   | .u8Sub τ e a b => .u8Sub (rewriteTyp subst mono τ) e
       (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b)
@@ -646,7 +641,7 @@ def collectInTypedTerm (seen : Std.HashSet (Global × Array Typ)) :
     args.attach.foldl (fun s ⟨a, _⟩ => collectInTypedTerm s a) seen
   | .add τ _ a b | .sub τ _ a b | .mul τ _ a b
   | .u8Xor τ _ a b | .u8Add τ _ a b | .u8Mul τ _ a b | .u8Sub τ _ a b
-  | .u8ChainRotr7 τ _ a b | .u8ChainRotr4 τ _ a b | .u8RangeCheck τ _ a b
+  | .u8ChainRotr _ τ _ a b | .u8RangeCheck τ _ a b
   | .unconstrainedBigUintDivMod τ _ a b
   | .u8And τ _ a b | .u8Or τ _ a b
   | .u8LessThan τ _ a b | .u32LessThan τ _ a b =>
@@ -717,7 +712,7 @@ def collectCalls (decls : Typed.Decls)
     bs.attach.foldl (fun s ⟨(_, b), _⟩ => collectCalls decls s b) seen
   | .add _ _ a b | .sub _ _ a b | .mul _ _ a b
   | .u8Xor _ _ a b | .u8Add _ _ a b | .u8Mul _ _ a b | .u8Sub _ _ a b
-  | .u8ChainRotr7 _ _ a b | .u8ChainRotr4 _ _ a b | .u8RangeCheck _ _ a b
+  | .u8ChainRotr _ _ _ a b | .u8RangeCheck _ _ a b
   | .unconstrainedBigUintDivMod _ _ a b
   | .u8And _ _ a b | .u8Or _ _ a b
   | .u8LessThan _ _ a b | .u32LessThan _ _ a b =>
@@ -821,9 +816,7 @@ def substInTypedTerm (subst : Global → Option Typ) : Typed.Term → Typed.Term
       (substInTypedTerm subst a) (substInTypedTerm subst b)
   | .u8Mul τ e a b => .u8Mul (Typ.instantiate subst τ) e
       (substInTypedTerm subst a) (substInTypedTerm subst b)
-  | .u8ChainRotr7 τ e a b => .u8ChainRotr7 (Typ.instantiate subst τ) e
-      (substInTypedTerm subst a) (substInTypedTerm subst b)
-  | .u8ChainRotr4 τ e a b => .u8ChainRotr4 (Typ.instantiate subst τ) e
+  | .u8ChainRotr k τ e a b => .u8ChainRotr k (Typ.instantiate subst τ) e
       (substInTypedTerm subst a) (substInTypedTerm subst b)
   | .u8Sub τ e a b => .u8Sub (Typ.instantiate subst τ) e
       (substInTypedTerm subst a) (substInTypedTerm subst b)
diff --git a/Ix/Aiur/Compiler/Layout.lean b/Ix/Aiur/Compiler/Layout.lean
index 94da06dc..bc3e5cc8 100644
--- a/Ix/Aiur/Compiler/Layout.lean
+++ b/Ix/Aiur/Compiler/Layout.lean
@@ -198,7 +198,7 @@ def opLayout : Bytecode.Op → LayoutM Unit
     pushDegree ((aDegree.max bDegree).max 1)
     bumpAuxiliaries; bumpLookups
   | .u8Mul .. => do pushDegrees #[1, 1]; bumpAuxiliaries 2; bumpLookups
-  | .u8ChainRotr7 .. | .u8ChainRotr4 .. => do pushDegrees #[1, 1, 1]; bumpAuxiliaries 3; bumpLookups
+  | .u8ChainRotr .. => do pushDegrees #[1, 1, 1]; bumpAuxiliaries 3; bumpLookups
   | .u8LessThan .. => do pushDegree 1; bumpAuxiliaries; bumpLookups
   | .u32LessThan .. => do pushDegree 1; bumpAuxiliaries 12; bumpLookups 6
   -- Pure range-check lookup: no output columns/degrees, just one lookup.
diff --git a/Ix/Aiur/Compiler/Lower.lean b/Ix/Aiur/Compiler/Lower.lean
index bd02acec..1ed0eaa7 100644
--- a/Ix/Aiur/Compiler/Lower.lean
+++ b/Ix/Aiur/Compiler/Lower.lean
@@ -306,12 +306,9 @@ def toIndex
   | .u8Mul _ _ i j => do
     let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j
     pushOp (.u8Mul i j) 2
-  | .u8ChainRotr7 _ _ i j => do
+  | .u8ChainRotr k _ _ i j => do
     let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j
-    pushOp (.u8ChainRotr7 i j) 3
-  | .u8ChainRotr4 _ _ i j => do
-    let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j
-    pushOp (.u8ChainRotr4 i j) 3
+    pushOp (.u8ChainRotr k i j) 3
   | .u8Sub _ _ i j => do
     let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j
     pushOp (.u8Sub i j) 2
diff --git a/Ix/Aiur/Compiler/Match.lean b/Ix/Aiur/Compiler/Match.lean
index 53c670a0..7347723e 100644
--- a/Ix/Aiur/Compiler/Match.lean
+++ b/Ix/Aiur/Compiler/Match.lean
@@ -382,8 +382,7 @@ def typedToSimple : Term → Simple.Term
   | .u8Xor τ e a b => .u8Xor τ e (typedToSimple a) (typedToSimple b)
   | .u8Add τ e a b => .u8Add τ e (typedToSimple a) (typedToSimple b)
   | .u8Mul τ e a b => .u8Mul τ e (typedToSimple a) (typedToSimple b)
-  | .u8ChainRotr7 τ e a b => .u8ChainRotr7 τ e (typedToSimple a) (typedToSimple b)
-  | .u8ChainRotr4 τ e a b => .u8ChainRotr4 τ e (typedToSimple a) (typedToSimple b)
+  | .u8ChainRotr k τ e a b => .u8ChainRotr k τ e (typedToSimple a) (typedToSimple b)
   | .u8Sub τ e a b => .u8Sub τ e (typedToSimple a) (typedToSimple b)
   | .u8And τ e a b => .u8And τ e (typedToSimple a) (typedToSimple b)
   | .u8Or τ e a b => .u8Or τ e (typedToSimple a) (typedToSimple b)
diff --git a/Ix/Aiur/Goldilocks.lean b/Ix/Aiur/Goldilocks.lean
index 8b431ad8..51a162c7 100644
--- a/Ix/Aiur/Goldilocks.lean
+++ b/Ix/Aiur/Goldilocks.lean
@@ -64,15 +64,13 @@ def G.u8Mul (a b : G) : G × G :=
 def G.u8Sub (a b : G) : G × G :=
   (G.ofNat ((a.n + 256 - b.n) % 256), if a.n < b.n then 1 else 0)
 
-/-- Chainable partial for a right-rotation by 7 bits over little-endian bytes.
-Returns `(a>>7 + b<<1, b>>7, a<<1)` (shifts mod 256). -/
-def G.u8ChainRotr7 (a b : G) : G × G × G :=
-  (G.ofNat (a.n / 128 + (b.n * 2) % 256), G.ofNat (b.n / 128), G.ofNat ((a.n * 2) % 256))
-
-/-- Chainable partial for a right-rotation by 4 bits over little-endian bytes.
-Returns `(a>>4 + b<<4, b>>4, a<<4)` (shifts mod 256). -/
-def G.u8ChainRotr4 (a b : G) : G × G × G :=
-  (G.ofNat (a.n / 16 + (b.n * 16) % 256), G.ofNat (b.n / 16), G.ofNat ((a.n * 16) % 256))
+/-- Chainable partial for a right-rotation by `k` bits (1..=7) over
+little-endian bytes. Returns `(a>>k + b<<(8-k), b>>k, a<<(8-k))`
+(shifts mod 256). -/
+def G.u8ChainRotr (k : Nat) (a b : G) : G × G × G :=
+  let hi := 2 ^ k
+  let lo := 2 ^ (8 - k)
+  (G.ofNat (a.n / hi + (b.n * lo) % 256), G.ofNat (b.n / hi), G.ofNat ((a.n * lo) % 256))
 
 def G.u8ShiftLeft  (a : G) : G := G.ofNat ((a.n * 2) % 256)
 def G.u8ShiftRight (a : G) : G := G.ofNat (a.n / 2)
diff --git a/Ix/Aiur/Interpret.lean b/Ix/Aiur/Interpret.lean
index 315b2dd7..0f76a935 100644
--- a/Ix/Aiur/Interpret.lean
+++ b/Ix/Aiur/Interpret.lean
@@ -358,24 +358,17 @@ partial def interp (decls : Decls) (bindings : Bindings) : Term → InterpM Valu
           let hi : Value := .field (G.ofUInt8 (x / 256).toUInt8)
           return .tuple #[lo, hi]
       | _, _ => throwErr "u8Mul: expected field values"
-  | .u8ChainRotr7 t1 t2 => do
+  | .u8ChainRotr k t1 t2 => do
       match (← interp decls bindings t1), (← interp decls bindings t2) with
       | .field a, .field b =>
           let i := a.val.toUInt8
           let j := b.val.toUInt8
-          return .tuple #[.field (G.ofUInt8 ((i >>> 7) + (j <<< 1))),
-                          .field (G.ofUInt8 (j >>> 7)),
-                          .field (G.ofUInt8 (i <<< 1))]
-      | _, _ => throwErr "u8ChainRotr7: expected field values"
-  | .u8ChainRotr4 t1 t2 => do
-      match (← interp decls bindings t1), (← interp decls bindings t2) with
-      | .field a, .field b =>
-          let i := a.val.toUInt8
-          let j := b.val.toUInt8
-          return .tuple #[.field (G.ofUInt8 ((i >>> 4) + (j <<< 4))),
-                          .field (G.ofUInt8 (j >>> 4)),
-                          .field (G.ofUInt8 (i <<< 4))]
-      | _, _ => throwErr "u8ChainRotr4: expected field values"
+          let hi := k.toUInt8
+          let lo := (8 - k).toUInt8
+          return .tuple #[.field (G.ofUInt8 ((i >>> hi) + (j <<< lo))),
+                          .field (G.ofUInt8 (j >>> hi)),
+                          .field (G.ofUInt8 (i <<< lo))]
+      | _, _ => throwErr "u8ChainRotr: expected field values"
   | .u8Sub t1 t2 => do
       match (← interp decls bindings t1), (← interp decls bindings t2) with
       | .field a, .field b =>
diff --git a/Ix/Aiur/Meta.lean b/Ix/Aiur/Meta.lean
index 4485453b..92a80c00 100644
--- a/Ix/Aiur/Meta.lean
+++ b/Ix/Aiur/Meta.lean
@@ -196,8 +196,7 @@ syntax "u8_shift_right" "(" aiur_trm ")"                                     : a
 syntax "u8_xor" "(" aiur_trm ", " aiur_trm ")"                              : aiur_trm
 syntax "u8_add" "(" aiur_trm ", " aiur_trm ")"                              : aiur_trm
 syntax "u8_mul" "(" aiur_trm ", " aiur_trm ")"                              : aiur_trm
-syntax "u8_chain_rotr7" "(" aiur_trm ", " aiur_trm ")"                      : aiur_trm
-syntax "u8_chain_rotr4" "(" aiur_trm ", " aiur_trm ")"                      : aiur_trm
+syntax "u8_chain_rotr" "(" num ", " aiur_trm ", " aiur_trm ")"              : aiur_trm
 syntax "u8_sub" "(" aiur_trm ", " aiur_trm ")"                              : aiur_trm
 syntax "u8_and" "(" aiur_trm ", " aiur_trm ")"                              : aiur_trm
 syntax "u8_or" "(" aiur_trm ", " aiur_trm ")"                               : aiur_trm
@@ -334,10 +333,8 @@ partial def elabTrm : ElabStxCat `aiur_trm
     mkAppM ``Source.Term.u8Add #[← elabTrm i, ← elabTrm j]
   | `(aiur_trm| u8_mul($i:aiur_trm, $j:aiur_trm)) => do
     mkAppM ``Source.Term.u8Mul #[← elabTrm i, ← elabTrm j]
-  | `(aiur_trm| u8_chain_rotr7($i:aiur_trm, $j:aiur_trm)) => do
-    mkAppM ``Source.Term.u8ChainRotr7 #[← elabTrm i, ← elabTrm j]
-  | `(aiur_trm| u8_chain_rotr4($i:aiur_trm, $j:aiur_trm)) => do
-    mkAppM ``Source.Term.u8ChainRotr4 #[← elabTrm i, ← elabTrm j]
+  | `(aiur_trm| u8_chain_rotr($k:num, $i:aiur_trm, $j:aiur_trm)) => do
+    mkAppM ``Source.Term.u8ChainRotr #[mkNatLit k.getNat, ← elabTrm i, ← elabTrm j]
   | `(aiur_trm| u8_sub($i:aiur_trm, $j:aiur_trm)) => do
     mkAppM ``Source.Term.u8Sub #[← elabTrm i, ← elabTrm j]
   | `(aiur_trm| u8_and($i:aiur_trm, $j:aiur_trm)) => do
@@ -551,14 +548,10 @@ where
       let i ← replaceToken old new i
       let j ← replaceToken old new j
       `(aiur_trm| u8_mul($i, $j))
-    | `(aiur_trm| u8_chain_rotr7($i:aiur_trm, $j:aiur_trm)) => do
+    | `(aiur_trm| u8_chain_rotr($k:num, $i:aiur_trm, $j:aiur_trm)) => do
       let i ← replaceToken old new i
       let j ← replaceToken old new j
-      `(aiur_trm| u8_chain_rotr7($i, $j))
-    | `(aiur_trm| u8_chain_rotr4($i:aiur_trm, $j:aiur_trm)) => do
-      let i ← replaceToken old new i
-      let j ← replaceToken old new j
-      `(aiur_trm| u8_chain_rotr4($i, $j))
+      `(aiur_trm| u8_chain_rotr($k, $i, $j))
     | `(aiur_trm| u8_sub($i:aiur_trm, $j:aiur_trm)) => do
       let i ← replaceToken old new i
       let j ← replaceToken old new j
diff --git a/Ix/Aiur/Semantics/BytecodeEval.lean b/Ix/Aiur/Semantics/BytecodeEval.lean
index 83b0ba57..6eab2041 100644
--- a/Ix/Aiur/Semantics/BytecodeEval.lean
+++ b/Ix/Aiur/Semantics/BytecodeEval.lean
@@ -260,18 +260,13 @@ def evalOp (t : Bytecode.Toplevel) (fuel : Nat) (op : Op) (st : EvalState) :
     let prod := x.val.toUInt8.toNat * y.val.toUInt8.toNat
     let st1 := pushMap st (G.ofUInt8 prod.toUInt8)
     pure (pushMap st1 (G.ofUInt8 (prod / 256).toUInt8))
-  | .u8ChainRotr7 a b => do
+  | .u8ChainRotr k a b => do
     let x ← readIdx st a; let y ← readIdx st b
     let i := x.val.toUInt8; let j := y.val.toUInt8
-    let st1 := pushMap st (G.ofUInt8 ((i >>> 7) + (j <<< 1)))
-    let st2 := pushMap st1 (G.ofUInt8 (j >>> 7))
-    pure (pushMap st2 (G.ofUInt8 (i <<< 1)))
-  | .u8ChainRotr4 a b => do
-    let x ← readIdx st a; let y ← readIdx st b
-    let i := x.val.toUInt8; let j := y.val.toUInt8
-    let st1 := pushMap st (G.ofUInt8 ((i >>> 4) + (j <<< 4)))
-    let st2 := pushMap st1 (G.ofUInt8 (j >>> 4))
-    pure (pushMap st2 (G.ofUInt8 (i <<< 4)))
+    let hi := k.toUInt8; let lo := (8 - k).toUInt8
+    let st1 := pushMap st (G.ofUInt8 ((i >>> hi) + (j <<< lo)))
+    let st2 := pushMap st1 (G.ofUInt8 (j >>> hi))
+    pure (pushMap st2 (G.ofUInt8 (i <<< lo)))
   | .u8Sub a b => do
     let x ← readIdx st a; let y ← readIdx st b
     let i := x.val.toUInt8; let j := y.val.toUInt8
diff --git a/Ix/Aiur/Semantics/SourceEval.lean b/Ix/Aiur/Semantics/SourceEval.lean
index 34f61ccc..28b2a1bb 100644
--- a/Ix/Aiur/Semantics/SourceEval.lean
+++ b/Ix/Aiur/Semantics/SourceEval.lean
@@ -390,22 +390,14 @@ def interp (decls : Decls) (fuel : Nat) (bindings : Bindings)
                    .field (G.ofUInt8 (x / 256).toUInt8)])
         (interp decls fuel bindings t1 st)
         (fun st1 => interp decls fuel bindings t2 st1)
-  | .u8ChainRotr7 t1 t2 =>
+  | .u8ChainRotr k t1 t2 =>
       combineFieldsResult
         (fun a b =>
           let i := a.val.toUInt8; let j := b.val.toUInt8
-          .tuple #[.field (G.ofUInt8 ((i >>> 7) + (j <<< 1))),
-                   .field (G.ofUInt8 (j >>> 7)),
-                   .field (G.ofUInt8 (i <<< 1))])
-        (interp decls fuel bindings t1 st)
-        (fun st1 => interp decls fuel bindings t2 st1)
-  | .u8ChainRotr4 t1 t2 =>
-      combineFieldsResult
-        (fun a b =>
-          let i := a.val.toUInt8; let j := b.val.toUInt8
-          .tuple #[.field (G.ofUInt8 ((i >>> 4) + (j <<< 4))),
-                   .field (G.ofUInt8 (j >>> 4)),
-                   .field (G.ofUInt8 (i <<< 4))])
+          let hi := k.toUInt8; let lo := (8 - k).toUInt8
+          .tuple #[.field (G.ofUInt8 ((i >>> hi) + (j <<< lo))),
+                   .field (G.ofUInt8 (j >>> hi)),
+                   .field (G.ofUInt8 (i <<< lo))])
         (interp decls fuel bindings t1 st)
         (fun st1 => interp decls fuel bindings t2 st1)
   | .u8Sub t1 t2 =>
diff --git a/Ix/Aiur/Stages/Bytecode.lean b/Ix/Aiur/Stages/Bytecode.lean
index 8950db99..d334bf05 100644
--- a/Ix/Aiur/Stages/Bytecode.lean
+++ b/Ix/Aiur/Stages/Bytecode.lean
@@ -43,12 +43,12 @@ inductive Op
   | u8Or : ValIdx → ValIdx → Op
   | u8LessThan : ValIdx → ValIdx → Op
   | u32LessThan : ValIdx → ValIdx → Op
-  | u8ChainRotr7 : ValIdx → ValIdx → Op
-  | u8ChainRotr4 : ValIdx → ValIdx → Op
+  /-- Chainable right-rotation by `k` bits (1..=7) over a byte pair. -/
+  | u8ChainRotr : Nat → ValIdx → ValIdx → Op
   | debug : String → Option (Array ValIdx) → Op
   /-- Range-check the two values into `[0, 256)` via the byte chip. Produces no
   new values: it is a pure side-effect (lookup), and its `u8` results alias the
-  two inputs. Kept last so its FFI tag (27) doesn't shift the others. -/
+  two inputs. Kept last so its FFI tag (26) doesn't shift the others. -/
   | u8RangeCheck : ValIdx → ValIdx → Op
   /-- Unconstrained LE byte-list division-modulo hint. Inputs are pointers to
   two `List<U64>` (klimbs) values. Produces 2 fresh pointer values
diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean
index ccab88b7..65c0b20f 100644
--- a/Ix/Aiur/Stages/Codegen.lean
+++ b/Ix/Aiur/Stages/Codegen.lean
@@ -348,7 +348,7 @@ def Op.outputCount : Op → Nat
   | .u8Xor _ _ | .u8And _ _ | .u8Or _ _ | .u8LessThan _ _ => 1
   | .u8Mul _ _ => 2
   | .u8Add _ _ | .u8Sub _ _ => 2
-  | .u8ChainRotr7 _ _ | .u8ChainRotr4 _ _ => 3
+  | .u8ChainRotr _ _ _ => 3
   | .u32LessThan _ _ => 1
   | .u8RangeCheck _ _ => 0
   | .unconstrainedBigUintDivMod _ _ => 2
@@ -549,7 +549,7 @@ private def emitU8Bytes2 (out : Nat) (valueHelper : String)
       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).
+    -- 2-tuple outputs (Mul) or 3-tuple (ChainRotr).
     let blockExpr : String :=
       s!"if unconstrained \{ Bytes2::{unconShortcut}(&__v_{i}, &__v_{j}) }" ++
       s!" else \{ {valueHelper}(__v_{i}, __v_{j}, record) }"
@@ -562,6 +562,20 @@ private def emitU8Bytes2 (out : Nat) (valueHelper : String)
       stmts := stmts.push (declVal (out + k) (.field (.var "__b2_out") (toString k)))
     return stmts
 
+/-- `Op::U8ChainRotr k`: parameterized chain rotation; the rotation
+    amount is baked into the generated call as a literal. -/
+private def emitU8ChainRotr (out : Nat) (k : Nat) (i j : ValIdx) :
+    Array RustStmt := Id.run do
+  let blockExpr : String :=
+    s!"if unconstrained \{ Bytes2::chain_rotr({k}, &__v_{i}, &__v_{j}) }" ++
+    s!" else \{ bytes2_chain_rotr_value({k}, __v_{i}, __v_{j}, record) }"
+  let mut stmts : Array RustStmt := #[
+    .letStmt false "__b2_out" (some "(G, G, G)") (.lit blockExpr)
+  ]
+  for m in [0 : 3] do
+    stmts := stmts.push (declVal (out + m) (.field (.var "__b2_out") (toString m)))
+  return stmts
+
 /-- `Op::U8Add`: gadget bumps `bytes2_queries.add` and returns
     `(low, carry)`. Codegen now calls `bytes2_add_value` ONCE in
     the constrained branch (vs the interpreter's two `Bytes2::add`
@@ -676,8 +690,7 @@ def emitOp (out : Nat) (op : Op) : Array RustStmt :=
   | .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
+  | .u8ChainRotr k i j => emitU8ChainRotr out k i j
   | .u8Add i j => emitU8Add out i j
   | .u8Sub i j => emitU8Sub out i j
   | .u32LessThan a b => emitU32LessThan out a b
@@ -932,8 +945,7 @@ def optionalExecuteUses : Array (String × String) := #[
   ("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"),
+  ("bytes2_chain_rotr_value", "bytes2_chain_rotr_value"),
   ("unconstrained_big_uint_div_mod_helper", "unconstrained_big_uint_div_mod_helper"),
   ("CodegenBytes1 as Bytes1", "Bytes1::"),
   ("CodegenBytes2 as Bytes2", "Bytes2::")
diff --git a/Ix/Aiur/Stages/Concrete.lean b/Ix/Aiur/Stages/Concrete.lean
index 1592509b..9ea96510 100644
--- a/Ix/Aiur/Stages/Concrete.lean
+++ b/Ix/Aiur/Stages/Concrete.lean
@@ -84,8 +84,8 @@ inductive Term : Type where
   | u8Or (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | u8LessThan (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | u32LessThan (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
-  | u8ChainRotr7 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
-  | u8ChainRotr4 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
+  /-- Chainable right-rotation by `k` bits (1..=7) over a byte pair. -/
+  | u8ChainRotr (k : Nat) (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | u8RangeCheck (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | unconstrainedBigUintDivMod (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | debug (typ : Typ) (escapes : Bool) (label : String) (t : Option Term) (r : Term) : Term
@@ -105,7 +105,7 @@ def Term.typ : Term → Typ
   | .u8BitDecomposition t _ _ | .u8ShiftLeft t _ _ | .u8ShiftRight t _ _
   | .u8Xor t _ _ _ | .u8Add t _ _ _ | .u8Mul t _ _ _ | .u8Sub t _ _ _
   | .u8And t _ _ _ | .u8Or t _ _ _ | .u8LessThan t _ _ _ | .u32LessThan t _ _ _
-  | .u8ChainRotr7 t _ _ _ | .u8ChainRotr4 t _ _ _ | .u8RangeCheck t _ _ _
+  | .u8ChainRotr _ t _ _ _ | .u8RangeCheck t _ _ _
   | .unconstrainedBigUintDivMod t _ _ _
   | .debug t _ _ _ _ => t
 
@@ -123,7 +123,7 @@ def Term.escapes : Term → Bool
   | .u8BitDecomposition _ e _ | .u8ShiftLeft _ e _ | .u8ShiftRight _ e _
   | .u8Xor _ e _ _ | .u8Add _ e _ _ | .u8Mul _ e _ _ | .u8Sub _ e _ _
   | .u8And _ e _ _ | .u8Or _ e _ _ | .u8LessThan _ e _ _ | .u32LessThan _ e _ _
-  | .u8ChainRotr7 _ e _ _ | .u8ChainRotr4 _ e _ _ | .u8RangeCheck _ e _ _
+  | .u8ChainRotr _ _ e _ _ | .u8RangeCheck _ e _ _
   | .unconstrainedBigUintDivMod _ e _ _
   | .debug _ e _ _ _ => e
 
diff --git a/Ix/Aiur/Stages/Simple.lean b/Ix/Aiur/Stages/Simple.lean
index 20d622d8..d7b68fd7 100644
--- a/Ix/Aiur/Stages/Simple.lean
+++ b/Ix/Aiur/Stages/Simple.lean
@@ -80,8 +80,8 @@ inductive Term : Type where
   | u8Or (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | u8LessThan (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | u32LessThan (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
-  | u8ChainRotr7 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
-  | u8ChainRotr4 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
+  /-- Chainable right-rotation by `k` bits (1..=7) over a byte pair. -/
+  | u8ChainRotr (k : Nat) (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | u8RangeCheck (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | unconstrainedBigUintDivMod (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | toField (typ : Typ) (escapes : Bool) (a : Term) : Term
@@ -102,7 +102,7 @@ def Term.typ : Term → Typ
   | .u8BitDecomposition t _ _ | .u8ShiftLeft t _ _ | .u8ShiftRight t _ _
   | .u8Xor t _ _ _ | .u8Add t _ _ _ | .u8Mul t _ _ _ | .u8Sub t _ _ _
   | .u8And t _ _ _ | .u8Or t _ _ _ | .u8LessThan t _ _ _ | .u32LessThan t _ _ _
-  | .u8ChainRotr7 t _ _ _ | .u8ChainRotr4 t _ _ _ | .u8RangeCheck t _ _ _
+  | .u8ChainRotr _ t _ _ _ | .u8RangeCheck t _ _ _
   | .unconstrainedBigUintDivMod t _ _ _
   | .toField t _ _ | .u8FromFieldUnsafe t _ _
   | .debug t _ _ _ _ => t
@@ -120,7 +120,7 @@ def Term.escapes : Term → Bool
   | .u8BitDecomposition _ e _ | .u8ShiftLeft _ e _ | .u8ShiftRight _ e _
   | .u8Xor _ e _ _ | .u8Add _ e _ _ | .u8Mul _ e _ _ | .u8Sub _ e _ _
   | .u8And _ e _ _ | .u8Or _ e _ _ | .u8LessThan _ e _ _ | .u32LessThan _ e _ _
-  | .u8ChainRotr7 _ e _ _ | .u8ChainRotr4 _ e _ _ | .u8RangeCheck _ e _ _
+  | .u8ChainRotr _ _ e _ _ | .u8RangeCheck _ e _ _
   | .unconstrainedBigUintDivMod _ e _ _
   | .toField _ e _ | .u8FromFieldUnsafe _ e _
   | .debug _ e _ _ _ => e
diff --git a/Ix/Aiur/Stages/Source.lean b/Ix/Aiur/Stages/Source.lean
index 7f96f4f8..0c2cbf57 100644
--- a/Ix/Aiur/Stages/Source.lean
+++ b/Ix/Aiur/Stages/Source.lean
@@ -430,8 +430,8 @@ inductive Term
   | u8Or : Term → Term → Term
   | u8LessThan : Term → Term → Term
   | u32LessThan : Term → Term → Term
-  | u8ChainRotr7 : Term → Term → Term
-  | u8ChainRotr4 : Term → Term → Term
+  /-- Chainable right-rotation by `k` bits (1..=7) over a byte pair. -/
+  | u8ChainRotr : Nat → Term → Term → Term
   /-- Unconstrained LE byte-list division-modulo hint. Inputs are two
   `List<U64>` (klimbs) values (LE limb order). Output is a tuple of two
   fresh `List<U64>` values `(q, r)` with `q*b + r = a` and `0 ≤ r < b`
@@ -670,8 +670,7 @@ def Term.freshen (cnt : Nat) (subst : Std.HashMap Local Local) :
   | .u8Or a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Or a' b')
   | .u8LessThan a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8LessThan a' b')
   | .u32LessThan a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u32LessThan a' b')
-  | .u8ChainRotr7 a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8ChainRotr7 a' b')
-  | .u8ChainRotr4 a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8ChainRotr4 a' b')
+  | .u8ChainRotr k a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8ChainRotr k a' b')
   | .unconstrainedBigUintDivMod a b =>
     let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .unconstrainedBigUintDivMod a' b')
   | .u8RangeCheck a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8RangeCheck a' b')
@@ -706,7 +705,7 @@ def Term.inlineCallSites : Term → List (Global × Nat)
   | .let _ v b => v.inlineCallSites ++ b.inlineCallSites
   | .add a b | .sub a b | .mul a b | .set a _ b
   | .u8Xor a b | .u8Add a b | .u8Mul a b | .u8Sub a b | .u8And a b | .u8Or a b
-  | .u8LessThan a b | .u32LessThan a b | .u8ChainRotr7 a b | .u8ChainRotr4 a b
+  | .u8LessThan a b | .u32LessThan a b | .u8ChainRotr _ a b
   | .unconstrainedBigUintDivMod a b | .u8RangeCheck a b | .ioGetInfo a b =>
     a.inlineCallSites ++ b.inlineCallSites
   | .assertEq a b c | .ioWrite a b c => a.inlineCallSites ++ b.inlineCallSites ++ c.inlineCallSites
@@ -812,8 +811,7 @@ def Term.expandOnce (done : Std.HashMap Global (List Local × Term)) (cnt : Nat)
   | .u8Or a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Or a' b')
   | .u8LessThan a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8LessThan a' b')
   | .u32LessThan a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u32LessThan a' b')
-  | .u8ChainRotr7 a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8ChainRotr7 a' b')
-  | .u8ChainRotr4 a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8ChainRotr4 a' b')
+  | .u8ChainRotr k a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8ChainRotr k a' b')
   | .unconstrainedBigUintDivMod a b =>
     let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .unconstrainedBigUintDivMod a' b')
   | .u8RangeCheck a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8RangeCheck a' b')
@@ -943,10 +941,8 @@ def Term.hoistLets : Term → Term :=
                        match cs with | [a, b] => Term.wrapLets fs (.u8LessThan a b) | _ => t
   | .u32LessThan a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
                         match cs with | [a, b] => Term.wrapLets fs (.u32LessThan a b) | _ => t
-  | .u8ChainRotr7 a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
-                         match cs with | [a, b] => Term.wrapLets fs (.u8ChainRotr7 a b) | _ => t
-  | .u8ChainRotr4 a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
-                         match cs with | [a, b] => Term.wrapLets fs (.u8ChainRotr4 a b) | _ => t
+  | .u8ChainRotr k a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                          match cs with | [a, b] => Term.wrapLets fs (.u8ChainRotr k a b) | _ => t
   | .unconstrainedBigUintDivMod a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
                                        match cs with | [a, b] => Term.wrapLets fs (.unconstrainedBigUintDivMod a b) | _ => t
   | .u8RangeCheck a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
diff --git a/Ix/Aiur/Stages/Typed.lean b/Ix/Aiur/Stages/Typed.lean
index 71e40a9c..00dce486 100644
--- a/Ix/Aiur/Stages/Typed.lean
+++ b/Ix/Aiur/Stages/Typed.lean
@@ -56,8 +56,8 @@ inductive Term : Type where
   | u8Or (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | u8LessThan (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | u32LessThan (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
-  | u8ChainRotr7 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
-  | u8ChainRotr4 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
+  /-- Chainable right-rotation by `k` bits (1..=7) over a byte pair. -/
+  | u8ChainRotr (k : Nat) (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | u8RangeCheck (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | unconstrainedBigUintDivMod (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | toField (typ : Typ) (escapes : Bool) (a : Term) : Term
@@ -78,7 +78,7 @@ def Term.typ : Term → Typ
   | .u8BitDecomposition t _ _ | .u8ShiftLeft t _ _ | .u8ShiftRight t _ _
   | .u8Xor t _ _ _ | .u8Add t _ _ _ | .u8Mul t _ _ _ | .u8Sub t _ _ _
   | .u8And t _ _ _ | .u8Or t _ _ _ | .u8LessThan t _ _ _ | .u32LessThan t _ _ _
-  | .u8ChainRotr7 t _ _ _ | .u8ChainRotr4 t _ _ _ | .u8RangeCheck t _ _ _
+  | .u8ChainRotr _ t _ _ _ | .u8RangeCheck t _ _ _
   | .unconstrainedBigUintDivMod t _ _ _
   | .toField t _ _ | .u8FromFieldUnsafe t _ _
   | .debug t _ _ _ _ => t
@@ -96,7 +96,7 @@ def Term.escapes : Term → Bool
   | .u8BitDecomposition _ e _ | .u8ShiftLeft _ e _ | .u8ShiftRight _ e _
   | .u8Xor _ e _ _ | .u8Add _ e _ _ | .u8Mul _ e _ _ | .u8Sub _ e _ _
   | .u8And _ e _ _ | .u8Or _ e _ _ | .u8LessThan _ e _ _ | .u32LessThan _ e _ _
-  | .u8ChainRotr7 _ e _ _ | .u8ChainRotr4 _ e _ _ | .u8RangeCheck _ e _ _
+  | .u8ChainRotr _ _ e _ _ | .u8RangeCheck _ e _ _
   | .unconstrainedBigUintDivMod _ e _ _
   | .toField _ e _ | .u8FromFieldUnsafe _ e _
   | .debug _ e _ _ _ => e
diff --git a/Ix/IxVM/Blake3.lean b/Ix/IxVM/Blake3.lean
index a7d87bff..5e99896f 100644
--- a/Ix/IxVM/Blake3.lean
+++ b/Ix/IxVM/Blake3.lean
@@ -344,15 +344,15 @@ def blake3 := ⟦
   fn rotr8(w: [U8; 4]) -> [U8; 4] { [w[1], w[2], w[3], w[0]] }
 
   fn rotr12(w: [U8; 4]) -> [U8; 4] {
-    let (e0, e1, e2) = u8_chain_rotr4(w[1], w[2]);
-    let (f0, f1, f2) = u8_chain_rotr4(w[3], w[0]);
+    let (e0, e1, e2) = u8_chain_rotr(4, w[1], w[2]);
+    let (f0, f1, f2) = u8_chain_rotr(4, w[3], w[0]);
     [e0, u8_from_field_unsafe(to_field(e1) + to_field(f2)), f0,
      u8_from_field_unsafe(to_field(f1) + to_field(e2))]
   }
 
   fn rotr7(w: [U8; 4]) -> [U8; 4] {
-    let (g0, g1, g2) = u8_chain_rotr7(w[0], w[1]);
-    let (h0, h1, h2) = u8_chain_rotr7(w[2], w[3]);
+    let (g0, g1, g2) = u8_chain_rotr(7, w[0], w[1]);
+    let (h0, h1, h2) = u8_chain_rotr(7, w[2], w[3]);
     [g0, u8_from_field_unsafe(to_field(g1) + to_field(h2)), h0,
      u8_from_field_unsafe(to_field(h1) + to_field(g2))]
   }
diff --git a/Tests/Aiur/Aiur.lean b/Tests/Aiur/Aiur.lean
index 8a6eeb1d..793b36ea 100644
--- a/Tests/Aiur/Aiur.lean
+++ b/Tests/Aiur/Aiur.lean
@@ -353,19 +353,19 @@ def toplevel := ⟦
   }
 
   pub fn u8_chain_rotr7_function(i: U8, j: U8) -> (U8, U8, U8) {
-    u8_chain_rotr7(i, j)
+    u8_chain_rotr(7, i, j)
   }
 
   pub fn u8_chain_rotr4_function(i: U8, j: U8) -> (U8, U8, U8) {
-    u8_chain_rotr4(i, j)
+    u8_chain_rotr(4, i, j)
   }
 
   -- Full u32 right-rotation by 7, built by chaining the partial gadget over
   -- adjacent little-endian byte pairs (2 lookups + 2 free field adds).
   pub fn u32_rotr7(b: [U8; 4]) -> [U8; 4] {
     let [b0, b1, b2, b3] = b;
-    let (a0, a1, a2) = u8_chain_rotr7(b0, b1);
-    let (c0, c1, c2) = u8_chain_rotr7(b2, b3);
+    let (a0, a1, a2) = u8_chain_rotr(7, b0, b1);
+    let (c0, c1, c2) = u8_chain_rotr(7, b2, b3);
     -- The two combined parts occupy disjoint bit positions, so their sum never
     -- overflows a byte: add cheaply as `G`, then reinterpret as `U8`.
     [a0, u8_from_field_unsafe(to_field(a1) + to_field(c2)), c0,
diff --git a/Tests/Aiur/Cross.lean b/Tests/Aiur/Cross.lean
index e318b88d..219e4e18 100644
--- a/Tests/Aiur/Cross.lean
+++ b/Tests/Aiur/Cross.lean
@@ -385,15 +385,15 @@ def toplevel : Source.Toplevel := ⟦
   pub fn u8_less_than_function(i: U8, j: U8) -> G { u8_less_than(i, j) }
   pub fn u8_and_function(i: U8, j: U8) -> U8 { u8_and(i, j) }
   pub fn u8_or_function(i: U8, j: U8) -> U8 { u8_or(i, j) }
-  pub fn u8_chain_rotr7_function(i: U8, j: U8) -> (U8, U8, U8) { u8_chain_rotr7(i, j) }
-  pub fn u8_chain_rotr4_function(i: U8, j: U8) -> (U8, U8, U8) { u8_chain_rotr4(i, j) }
+  pub fn u8_chain_rotr7_function(i: U8, j: U8) -> (U8, U8, U8) { u8_chain_rotr(7, i, j) }
+  pub fn u8_chain_rotr4_function(i: U8, j: U8) -> (U8, U8, U8) { u8_chain_rotr(4, i, j) }
 
   -- Full u32 right-rotation by 7, built by chaining the partial gadget over
   -- adjacent little-endian byte pairs (2 lookups + 2 free field adds).
   pub fn u32_rotr7(b: [U8; 4]) -> [U8; 4] {
     let [b0, b1, b2, b3] = b;
-    let (a0, a1, a2) = u8_chain_rotr7(b0, b1);
-    let (c0, c1, c2) = u8_chain_rotr7(b2, b3);
+    let (a0, a1, a2) = u8_chain_rotr(7, b0, b1);
+    let (c0, c1, c2) = u8_chain_rotr(7, b2, b3);
     -- The two combined parts occupy disjoint bit positions, so their sum never
     -- overflows a byte: add cheaply as `G`, then reinterpret as `U8`.
     [a0, u8_from_field_unsafe(to_field(a1) + to_field(c2)), c0,
diff --git a/crates/aiur/src/bytecode.rs b/crates/aiur/src/bytecode.rs
index 6f1b6be8..4b68355a 100644
--- a/crates/aiur/src/bytecode.rs
+++ b/crates/aiur/src/bytecode.rs
@@ -58,8 +58,8 @@ pub enum Op {
   U8Or(ValIdx, ValIdx),
   U8LessThan(ValIdx, ValIdx),
   U32LessThan(ValIdx, ValIdx),
-  U8ChainRotr7(ValIdx, ValIdx),
-  U8ChainRotr4(ValIdx, ValIdx),
+  /// Chainable right-rotation by `k` bits (1..=7) over a byte pair.
+  U8ChainRotr(u8, ValIdx, ValIdx),
   Debug(String, Option<Vec<ValIdx>>),
   /// Range-check two values into `[0, 256)` via the byte chip. Produces no new
   /// values: its `u8` results alias the two inputs (cf. `AssertEq`).
diff --git a/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs
index 93fda0e0..cd440975 100644
--- a/crates/aiur/src/constraints.rs
+++ b/crates/aiur/src/constraints.rs
@@ -16,9 +16,9 @@ use crate::{
     bytes2::{Bytes2, Bytes2Op},
   },
   memory_channel, u8_add_channel, u8_and_channel, u8_bit_decomposition_channel,
-  u8_chain_rotr4_channel, u8_chain_rotr7_channel, u8_less_than_channel,
-  u8_mul_channel, u8_or_channel, u8_range_check_channel, u8_shift_left_channel,
-  u8_shift_right_channel, u8_sub_channel, u8_xor_channel,
+  u8_chain_rotr_channel, u8_less_than_channel, u8_mul_channel, u8_or_channel,
+  u8_range_check_channel, u8_shift_left_channel, u8_shift_right_channel,
+  u8_sub_channel, u8_xor_channel,
 };
 
 type Expr = SymbolicExpression<G>;
@@ -561,19 +561,11 @@ impl Op {
         sel.clone(),
         state,
       ),
-      Op::U8ChainRotr7(i, j) => bytes2_constraints(
+      Op::U8ChainRotr(k, i, j) => bytes2_constraints(
         *i,
         *j,
-        &Bytes2Op::ChainRotr7,
-        u8_chain_rotr7_channel(),
-        sel.clone(),
-        state,
-      ),
-      Op::U8ChainRotr4(i, j) => bytes2_constraints(
-        *i,
-        *j,
-        &Bytes2Op::ChainRotr4,
-        u8_chain_rotr4_channel(),
+        &Bytes2Op::ChainRotr(*k),
+        u8_chain_rotr_channel(*k),
         sel.clone(),
         state,
       ),
diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs
index 561f2ee3..c77a560f 100644
--- a/crates/aiur/src/execute.rs
+++ b/crates/aiur/src/execute.rs
@@ -516,20 +516,12 @@ impl Function {
             }
           }
         },
-        ExecEntry::Op(Op::U8ChainRotr7(i, j)) => {
+        ExecEntry::Op(Op::U8ChainRotr(k, i, j)) => {
           if unconstrained {
-            let (o0, o1, o2) = Bytes2::chain_rotr7(&map[*i], &map[*j]);
+            let (o0, o1, o2) = Bytes2::chain_rotr(*k, &map[*i], &map[*j]);
             map.extend([o0, o1, o2]);
           } else {
-            bytes2_execute(*i, *j, &Bytes2Op::ChainRotr7, &mut map, record);
-          }
-        },
-        ExecEntry::Op(Op::U8ChainRotr4(i, j)) => {
-          if unconstrained {
-            let (o0, o1, o2) = Bytes2::chain_rotr4(&map[*i], &map[*j]);
-            map.extend([o0, o1, o2]);
-          } else {
-            bytes2_execute(*i, *j, &Bytes2Op::ChainRotr4, &mut map, record);
+            bytes2_execute(*i, *j, &Bytes2Op::ChainRotr(*k), &mut map, record);
           }
         },
         ExecEntry::Op(Op::U8RangeCheck(i, j)) => {
@@ -772,14 +764,25 @@ pub fn bytes2_mul_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) {
   Bytes2::mul(&a, &b)
 }
 
+#[inline]
+pub fn bytes2_chain_rotr_value(
+  k: u8,
+  a: G,
+  b: G,
+  record: &mut QueryRecord,
+) -> (G, G, G) {
+  record.bytes2_queries.bump_chain_rotr(k, &a, &b);
+  Bytes2::chain_rotr(k, &a, &b)
+}
+
+/// Legacy fixed-amount aliases, referenced by the codegen'd IxVM kernel.
 #[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)
+  bytes2_chain_rotr_value(7, a, b, record)
 }
 
 #[inline]
@@ -788,8 +791,7 @@ pub fn bytes2_chain_rotr4_value(
   b: G,
   record: &mut QueryRecord,
 ) -> (G, G, G) {
-  record.bytes2_queries.bump_chain_rotr4(&a, &b);
-  Bytes2::chain_rotr4(&a, &b)
+  bytes2_chain_rotr_value(4, a, b, record)
 }
 
 /// Bumps `bytes2_queries.add` and returns the full `(low, carry)`
diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs
index be47be65..b55d98f4 100644
--- a/crates/aiur/src/gadgets/bytes2.rs
+++ b/crates/aiur/src/gadgets/bytes2.rs
@@ -8,9 +8,8 @@ use multi_stark::{
 
 use crate::{
   G, execute::QueryRecord, gadgets::AiurGadget, u8_add_channel, u8_and_channel,
-  u8_chain_rotr4_channel, u8_chain_rotr7_channel, u8_less_than_channel,
-  u8_mul_channel, u8_or_channel, u8_range_check_channel, u8_sub_channel,
-  u8_xor_channel,
+  u8_chain_rotr_channel, u8_less_than_channel, u8_mul_channel, u8_or_channel,
+  u8_range_check_channel, u8_sub_channel, u8_xor_channel,
 };
 
 /// Number of columns in the trace with multiplicities for
@@ -22,9 +21,8 @@ use crate::{
 /// - less_than
 /// - range_check
 /// - mul
-/// - chain_rotr7
-/// - chain_rotr4
-const TRACE_WIDTH: usize = 10;
+/// - chain_rotr1 .. chain_rotr7 (one column per rotation amount)
+const TRACE_WIDTH: usize = 15;
 
 /// Number of columns in the preprocessed trace:
 /// - first raw byte value
@@ -39,13 +37,22 @@ const TRACE_WIDTH: usize = 10;
 /// - less_than result
 /// - mul low byte
 /// - mul high byte
-/// - chain_rotr7 output 0 (`i >> 7 + j << 1`)
-/// - chain_rotr7 output 1 (`j >> 7`)
-/// - chain_rotr7 output 2 (`i << 1`)
-/// - chain_rotr4 output 0 (`i >> 4 + j << 4`)
-/// - chain_rotr4 output 1 (`j >> 4`)
-/// - chain_rotr4 output 2 (`i << 4`)
-const PREPROCESSED_TRACE_WIDTH: usize = 16;
+/// - for each k in 1..=7, chain_rotr{k} outputs 0..2:
+///   (`i >> k + j << (8-k)`, `j >> k`, `i << (8-k)`)
+const PREPROCESSED_TRACE_WIDTH: usize = 10 + 3 * 7;
+
+/// Column index of the `chain_rotr{k}` multiplicity in the main trace.
+#[inline]
+const fn chain_rotr_trace_col(k: u8) -> usize {
+  7 + k as usize
+}
+
+/// Column index of `chain_rotr{k}` output 0 in the preprocessed trace
+/// (outputs 1 and 2 follow contiguously).
+#[inline]
+const fn chain_rotr_preprocessed_col(k: u8) -> usize {
+  10 + 3 * (k as usize - 1)
+}
 
 /// AIR implementer for arity 2 byte-related lookups.
 pub struct Bytes2;
@@ -58,8 +65,8 @@ pub enum Bytes2Op {
   And,
   Or,
   LessThan,
-  ChainRotr7,
-  ChainRotr4,
+  /// Chainable right-rotation by `k` bits (1..=7) over a byte pair.
+  ChainRotr(u8),
 }
 
 impl BaseAir<G> for Bytes2 {
@@ -100,17 +107,13 @@ impl BaseAir<G> for Bytes2 {
         trace_values.push(G::from_u8((p & 0xff) as u8));
         trace_values.push(G::from_u8((p >> 8) as u8));
 
-        // Chain rotr7 (combined byte, j high bit, i low part)
-        let (o0, o1, o2) = Self::chain_rotr7_u8(i, j);
-        trace_values.push(G::from_u8(o0));
-        trace_values.push(G::from_u8(o1));
-        trace_values.push(G::from_u8(o2));
-
-        // Chain rotr4 (combined byte, j high nibble, i low nibble)
-        let (o0, o1, o2) = Self::chain_rotr4_u8(i, j);
-        trace_values.push(G::from_u8(o0));
-        trace_values.push(G::from_u8(o1));
-        trace_values.push(G::from_u8(o2));
+        // Chain rotr{k} (combined byte, j high part, i low part)
+        for k in 1..=7 {
+          let (o0, o1, o2) = Self::chain_rotr_u8(k, i, j);
+          trace_values.push(G::from_u8(o0));
+          trace_values.push(G::from_u8(o1));
+          trace_values.push(G::from_u8(o2));
+        }
       }
     }
     Some(RowMajorMatrix::new(trace_values, PREPROCESSED_TRACE_WIDTH))
@@ -134,7 +137,7 @@ impl AiurGadget for Bytes2 {
       | Bytes2Op::Add
       | Bytes2Op::Sub => 1,
       Bytes2Op::Mul => 2,
-      Bytes2Op::ChainRotr7 | Bytes2Op::ChainRotr4 => 3,
+      Bytes2Op::ChainRotr(_) => 3,
     }
   }
 
@@ -178,14 +181,9 @@ impl AiurGadget for Bytes2 {
         record.bytes2_queries.bump_less_than(i, j);
         vec![Self::less_than(i, j)]
       },
-      Bytes2Op::ChainRotr7 => {
-        record.bytes2_queries.bump_chain_rotr7(i, j);
-        let (o0, o1, o2) = Self::chain_rotr7(i, j);
-        vec![o0, o1, o2]
-      },
-      Bytes2Op::ChainRotr4 => {
-        record.bytes2_queries.bump_chain_rotr4(i, j);
-        let (o0, o1, o2) = Self::chain_rotr4(i, j);
+      Bytes2Op::ChainRotr(k) => {
+        record.bytes2_queries.bump_chain_rotr(*k, i, j);
+        let (o0, o1, o2) = Self::chain_rotr(*k, i, j);
         vec![o0, o1, o2]
       },
     }
@@ -201,8 +199,6 @@ impl AiurGadget for Bytes2 {
     let less_than_channel = u8_less_than_channel().into();
     let range_check_channel = u8_range_check_channel().into();
     let mul_channel = u8_mul_channel().into();
-    let chain_rotr7_channel = u8_chain_rotr7_channel().into();
-    let chain_rotr4_channel = u8_chain_rotr4_channel().into();
 
     // Multiplicity columns
     let xor_multiplicity = var(0);
@@ -213,8 +209,6 @@ impl AiurGadget for Bytes2 {
     let less_than_multiplicity = var(5);
     let range_check_multiplicity = var(6);
     let mul_multiplicity = var(7);
-    let chain_rotr7_multiplicity = var(8);
-    let chain_rotr4_multiplicity = var(9);
 
     // Preprocessed columns
     let i = preprocessed_var(0);
@@ -227,12 +221,6 @@ impl AiurGadget for Bytes2 {
     let less_than = preprocessed_var(7);
     let mul_lo = preprocessed_var(8);
     let mul_hi = preprocessed_var(9);
-    let chain_rotr7_o0 = preprocessed_var(10);
-    let chain_rotr7_o1 = preprocessed_var(11);
-    let chain_rotr7_o2 = preprocessed_var(12);
-    let chain_rotr4_o0 = preprocessed_var(13);
-    let chain_rotr4_o1 = preprocessed_var(14);
-    let chain_rotr4_o2 = preprocessed_var(15);
 
     let pull_xor = Lookup::pull(
       xor_multiplicity,
@@ -272,31 +260,22 @@ impl AiurGadget for Bytes2 {
       vec![range_check_channel, i.clone(), j.clone()],
     );
 
-    let pull_chain_rotr7 = Lookup::pull(
-      chain_rotr7_multiplicity,
-      vec![
-        chain_rotr7_channel,
-        i.clone(),
-        j.clone(),
-        chain_rotr7_o0,
-        chain_rotr7_o1,
-        chain_rotr7_o2,
-      ],
-    );
-
-    let pull_chain_rotr4 = Lookup::pull(
-      chain_rotr4_multiplicity,
-      vec![
-        chain_rotr4_channel,
-        i,
-        j,
-        chain_rotr4_o0,
-        chain_rotr4_o1,
-        chain_rotr4_o2,
-      ],
-    );
-
-    vec![
+    let pull_chain_rotrs = (1..=7u8).map(|k| {
+      let col = chain_rotr_preprocessed_col(k);
+      Lookup::pull(
+        var(chain_rotr_trace_col(k)),
+        vec![
+          u8_chain_rotr_channel(k).into(),
+          i.clone(),
+          j.clone(),
+          preprocessed_var(col),
+          preprocessed_var(col + 1),
+          preprocessed_var(col + 2),
+        ],
+      )
+    });
+
+    let mut lookups = vec![
       pull_xor,
       pull_add,
       pull_sub,
@@ -305,9 +284,9 @@ impl AiurGadget for Bytes2 {
       pull_less_than,
       pull_range_check,
       pull_mul,
-      pull_chain_rotr7,
-      pull_chain_rotr4,
-    ]
+    ];
+    lookups.extend(pull_chain_rotrs);
+    lookups
   }
 
   fn witness_data(
@@ -327,96 +306,64 @@ impl AiurGadget for Bytes2 {
     let less_than_channel = u8_less_than_channel();
     let range_check_channel = u8_range_check_channel();
     let mul_channel = u8_mul_channel();
-    let chain_rotr7_channel = u8_chain_rotr7_channel();
-    let chain_rotr4_channel = u8_chain_rotr4_channel();
 
     rows
       .chunks_exact_mut(TRACE_WIDTH)
       .enumerate()
       .zip(&record.bytes2_queries.0)
       .zip(&mut lookups)
-      .for_each(
-        |(
-          (
-            (row_idx, row),
-            &[
-              xor,
-              add,
-              sub,
-              and,
-              or,
-              less_than,
-              range_check,
-              mul,
-              chain_rotr7,
-              chain_rotr4,
-            ],
-          ),
-          row_lookups,
-        )| {
-          let i = G::from_usize(row_idx / 256);
-          let j = G::from_usize(row_idx % 256);
-
-          row[0] = xor;
-          row[1] = add;
-          row[2] = sub;
-          row[3] = and;
-          row[4] = or;
-          row[5] = less_than;
-          row[6] = range_check;
-          row[7] = mul;
-          row[8] = chain_rotr7;
-          row[9] = chain_rotr4;
-
-          // Pull xor.
-          row_lookups[0] =
-            Lookup::pull(xor, vec![xor_channel, i, j, Self::xor(&i, &j)]);
-
-          // Pull add (low byte only; carry derived in-circuit).
-          let (r, _o) = Self::add(&i, &j);
-          row_lookups[1] = Lookup::pull(add, vec![add_channel, i, j, r]);
-
-          // Pull sub (low byte only; borrow derived in-circuit).
-          let (r, _u) = Self::sub(&i, &j);
-          row_lookups[2] = Lookup::pull(sub, vec![sub_channel, i, j, r]);
-
-          // Pull and.
-          row_lookups[3] =
-            Lookup::pull(and, vec![and_channel, i, j, Self::and(&i, &j)]);
-
-          // Pull or.
-          row_lookups[4] =
-            Lookup::pull(or, vec![or_channel, i, j, Self::or(&i, &j)]);
-
-          // Pull less_than.
-          row_lookups[5] = Lookup::pull(
-            less_than,
-            vec![less_than_channel, i, j, Self::less_than(&i, &j)],
-          );
-
-          // Pull range_check.
-          row_lookups[6] =
-            Lookup::pull(range_check, vec![range_check_channel, i, j]);
-
-          // Pull mul.
-          let (lo, hi) = Self::mul(&i, &j);
-          row_lookups[7] = Lookup::pull(mul, vec![mul_channel, i, j, lo, hi]);
-
-          // Pull chain_rotr7.
-          let (o0, o1, o2) = Self::chain_rotr7(&i, &j);
-          row_lookups[8] = Lookup::pull(
-            chain_rotr7,
-            vec![chain_rotr7_channel, i, j, o0, o1, o2],
+      .for_each(|(((row_idx, row), multiplicities), row_lookups)| {
+        let [xor, add, sub, and, or, less_than, range_check, mul, ..] =
+          *multiplicities;
+        let i = G::from_usize(row_idx / 256);
+        let j = G::from_usize(row_idx % 256);
+
+        row.copy_from_slice(multiplicities);
+
+        // Pull xor.
+        row_lookups[0] =
+          Lookup::pull(xor, vec![xor_channel, i, j, Self::xor(&i, &j)]);
+
+        // Pull add (low byte only; carry derived in-circuit).
+        let (r, _o) = Self::add(&i, &j);
+        row_lookups[1] = Lookup::pull(add, vec![add_channel, i, j, r]);
+
+        // Pull sub (low byte only; borrow derived in-circuit).
+        let (r, _u) = Self::sub(&i, &j);
+        row_lookups[2] = Lookup::pull(sub, vec![sub_channel, i, j, r]);
+
+        // Pull and.
+        row_lookups[3] =
+          Lookup::pull(and, vec![and_channel, i, j, Self::and(&i, &j)]);
+
+        // Pull or.
+        row_lookups[4] =
+          Lookup::pull(or, vec![or_channel, i, j, Self::or(&i, &j)]);
+
+        // Pull less_than.
+        row_lookups[5] = Lookup::pull(
+          less_than,
+          vec![less_than_channel, i, j, Self::less_than(&i, &j)],
+        );
+
+        // Pull range_check.
+        row_lookups[6] =
+          Lookup::pull(range_check, vec![range_check_channel, i, j]);
+
+        // Pull mul.
+        let (lo, hi) = Self::mul(&i, &j);
+        row_lookups[7] = Lookup::pull(mul, vec![mul_channel, i, j, lo, hi]);
+
+        // Pull chain_rotr{k}.
+        for k in 1..=7u8 {
+          let col = chain_rotr_trace_col(k);
+          let (o0, o1, o2) = Self::chain_rotr(k, &i, &j);
+          row_lookups[col] = Lookup::pull(
+            multiplicities[col],
+            vec![u8_chain_rotr_channel(k), i, j, o0, o1, o2],
           );
-
-          // Pull chain_rotr4.
-          let (o0, o1, o2) = Self::chain_rotr4(&i, &j);
-          row_lookups[9] = Lookup::pull(
-            chain_rotr4,
-            vec![chain_rotr4_channel, i, j, o0, o1, o2],
-          );
-        },
-      );
+        }
+      });
     (RowMajorMatrix::new(rows, TRACE_WIDTH), lookups)
   }
 }
@@ -462,12 +409,8 @@ impl Bytes2Queries {
     self.bump_multiplicity_for(i, j, 7)
   }
 
-  pub(crate) fn bump_chain_rotr7(&mut self, i: &G, j: &G) {
-    self.bump_multiplicity_for(i, j, 8)
-  }
-
-  pub(crate) fn bump_chain_rotr4(&mut self, i: &G, j: &G) {
-    self.bump_multiplicity_for(i, j, 9)
+  pub(crate) fn bump_chain_rotr(&mut self, k: u8, i: &G, j: &G) {
+    self.bump_multiplicity_for(i, j, chain_rotr_trace_col(k))
   }
 
   pub(crate) fn bump_multiplicity_for(&mut self, i: &G, j: &G, col: usize) {
@@ -532,39 +475,35 @@ impl Bytes2 {
     (G::from_u8((p & 0xff) as u8), G::from_u8((p >> 8) as u8))
   }
 
-  /// Chainable building block for a right-rotation by 7 bits over a sequence
-  /// of little-endian bytes. Given adjacent bytes `i`, `j`, returns
-  /// `(i>>7 + j<<1, j>>7, i<<1)` where shifts are taken mod 256. Chaining the
-  /// outputs across all adjacent byte pairs yields a `rotr7` of any width
-  /// (u16, u32, u64, ...): e.g. the u32 `rotr7` of `[b0,b1,b2,b3]` is
-  /// `[A0, A1+B2, B0, B1+A2]` for `A = chain_rotr7(b0,b1)`,
+  /// Chainable building block for a right-rotation by `k` bits (1..=7) over a
+  /// sequence of little-endian bytes. Given adjacent bytes `i`, `j`, returns
+  /// `(i>>k + j<<(8-k), j>>k, i<<(8-k))` where shifts are taken mod 256.
+  /// Chaining the outputs across all adjacent byte pairs yields a `rotr{k}`
+  /// of any width (u16, u32, u64, ...): e.g. the u32 `rotr7` of
+  /// `[b0,b1,b2,b3]` is `[A0, A1+B2, B0, B1+A2]` for `A = chain_rotr7(b0,b1)`,
   /// `B = chain_rotr7(b2,b3)`.
   #[inline]
-  pub fn chain_rotr7_u8(i: u8, j: u8) -> (u8, u8, u8) {
-    ((i >> 7) + (j << 1), j >> 7, i << 1)
+  pub fn chain_rotr_u8(k: u8, i: u8, j: u8) -> (u8, u8, u8) {
+    debug_assert!((1..=7).contains(&k));
+    ((i >> k) + (j << (8 - k)), j >> k, i << (8 - k))
   }
 
-  /// Chainable building block for a right-rotation by 4 bits over a sequence
-  /// 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 fn chain_rotr4_u8(i: u8, j: u8) -> (u8, u8, u8) {
-    ((i >> 4) + (j << 4), j >> 4, i << 4)
+  pub fn chain_rotr(k: u8, 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_rotr_u8(k, i, j);
+    (G::from_u8(o0), G::from_u8(o1), G::from_u8(o2))
   }
 
+  /// Legacy fixed-amount aliases, used by the codegen'd IxVM kernel.
   #[inline]
   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);
-    (G::from_u8(o0), G::from_u8(o1), G::from_u8(o2))
+    Self::chain_rotr(7, i, j)
   }
 
   #[inline]
   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);
-    (G::from_u8(o0), G::from_u8(o1), G::from_u8(o2))
+    Self::chain_rotr(4, i, j)
   }
 }
diff --git a/crates/aiur/src/lib.rs b/crates/aiur/src/lib.rs
index 605c8382..b8621e30 100644
--- a/crates/aiur/src/lib.rs
+++ b/crates/aiur/src/lib.rs
@@ -80,12 +80,9 @@ pub fn u8_mul_channel() -> G {
   G::from_u8(12)
 }
 
+/// Channel for the chainable right-rotation by `k` bits (1..=7): 13..=19.
 #[inline]
-pub fn u8_chain_rotr7_channel() -> G {
-  G::from_u8(13)
-}
-
-#[inline]
-pub fn u8_chain_rotr4_channel() -> G {
-  G::from_u8(14)
+pub fn u8_chain_rotr_channel(k: u8) -> G {
+  debug_assert!((1..=7).contains(&k));
+  G::from_u8(12 + k)
 }
diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs
index 5b45d06c..cf998d68 100644
--- a/crates/aiur/src/trace.rs
+++ b/crates/aiur/src/trace.rs
@@ -20,9 +20,9 @@ use crate::{
   gadgets::{bytes1::Bytes1, bytes2::Bytes2},
   memory::Memory,
   u8_add_channel, u8_and_channel, u8_bit_decomposition_channel,
-  u8_chain_rotr4_channel, u8_chain_rotr7_channel, u8_less_than_channel,
-  u8_mul_channel, u8_or_channel, u8_range_check_channel, u8_shift_left_channel,
-  u8_shift_right_channel, u8_sub_channel, u8_xor_channel,
+  u8_chain_rotr_channel, u8_less_than_channel, u8_mul_channel, u8_or_channel,
+  u8_range_check_channel, u8_shift_left_channel, u8_shift_right_channel,
+  u8_sub_channel, u8_xor_channel,
 };
 
 struct ColumnIndex {
@@ -484,30 +484,17 @@ impl Op {
         let lookup_args = vec![u8_less_than_channel(), i, j, less_than];
         slice.push_lookup(index, Lookup::push(G::ONE, lookup_args));
       },
-      Op::U8ChainRotr7(i, j) => {
+      Op::U8ChainRotr(k, i, j) => {
         let (i, _) = map[*i];
         let (j, _) = map[*j];
-        let (o0, o1, o2) = Bytes2::chain_rotr7(&i, &j);
+        let (o0, o1, o2) = Bytes2::chain_rotr(*k, &i, &j);
         map.push((o0, 1));
         map.push((o1, 1));
         map.push((o2, 1));
         slice.push_auxiliary(index, o0);
         slice.push_auxiliary(index, o1);
         slice.push_auxiliary(index, o2);
-        let lookup_args = vec![u8_chain_rotr7_channel(), i, j, o0, o1, o2];
-        slice.push_lookup(index, Lookup::push(G::ONE, lookup_args));
-      },
-      Op::U8ChainRotr4(i, j) => {
-        let (i, _) = map[*i];
-        let (j, _) = map[*j];
-        let (o0, o1, o2) = Bytes2::chain_rotr4(&i, &j);
-        map.push((o0, 1));
-        map.push((o1, 1));
-        map.push((o2, 1));
-        slice.push_auxiliary(index, o0);
-        slice.push_auxiliary(index, o1);
-        slice.push_auxiliary(index, o2);
-        let lookup_args = vec![u8_chain_rotr4_channel(), i, j, o0, o1, o2];
+        let lookup_args = vec![u8_chain_rotr_channel(*k), i, j, o0, o1, o2];
         slice.push_lookup(index, Lookup::push(G::ONE, lookup_args));
       },
       Op::U32LessThan(x_idx, y_idx) => {
diff --git a/crates/ffi/src/aiur/toplevel.rs b/crates/ffi/src/aiur/toplevel.rs
index bb9cdfdf..b5865b0b 100644
--- a/crates/ffi/src/aiur/toplevel.rs
+++ b/crates/ffi/src/aiur/toplevel.rs
@@ -132,14 +132,10 @@ fn decode_op(ctor: LeanCtor<LeanBorrowed<'_>>) -> Op {
       Op::U32LessThan(i, j)
     },
     24 => {
-      let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x));
-      Op::U8ChainRotr7(i, j)
+      let [k, i, j] = ctor.objs::<3>().map(|x| lean_unbox_nat_as_usize(&x));
+      Op::U8ChainRotr(k.try_into().unwrap(), i, j)
     },
     25 => {
-      let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x));
-      Op::U8ChainRotr4(i, j)
-    },
-    26 => {
       let [label_obj, idxs_obj] = ctor.objs::<2>();
       let label = label_obj.as_string().to_string();
       let idxs = if idxs_obj.is_scalar() {
@@ -150,11 +146,11 @@ fn decode_op(ctor: LeanCtor<LeanBorrowed<'_>>) -> Op {
       };
       Op::Debug(label, idxs)
     },
-    27 => {
+    26 => {
       let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x));
       Op::U8RangeCheck(i, j)
     },
-    28 => {
+    27 => {
       let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x));
       Op::UnconstrainedBigUintDivMod(i, j)
     },

From c99ada5befd9cbcce3af8b6f002956c1cf78ecf3 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Mon, 13 Jul 2026 14:49:47 +0000
Subject: [PATCH 21/22] keccak: self-recursive rounds; rho via the chain-rotr
 gadget
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

keccak_round tail-recurses on a round index: a shared-column match
yields the iota constant (only RC bytes 0, 1, 3 and 7 are ever
non-zero, so iota xors just four state bytes), round 23 returns, and
absorb_blocks calls keccak_round(s, 0) directly — deleting keccak_f,
whose 24 call sites materialized 24 x (200 aux + 1 lookup) columns.

rho (and theta's rotl-by-1) move from 1-4 chained u8_add/u8_shift
passes per lane (24-96 columns) to 4 chain-rotr lookups per lane (20
columns); the wiring is script-generated and asserted against a
reference 64-bit rotation.

512 KiB grid: total width 10604 -> 5018 (-53%), throughput 23.4 ->
27.9 KiB/s (+19%); keccak_round lands at 3414 columns.
---
 Ix/IxVM/Keccak.lean | 587 +++++++++++++-------------------------------
 1 file changed, 176 insertions(+), 411 deletions(-)

diff --git a/Ix/IxVM/Keccak.lean b/Ix/IxVM/Keccak.lean
index 4649f7ea..12be7a30 100644
--- a/Ix/IxVM/Keccak.lean
+++ b/Ix/IxVM/Keccak.lean
@@ -7,16 +7,16 @@ public import Ix.Aiur.Meta
 Same algorithm/variant as `Ix/MultiStark/Keccak.lean` (Ethereum keccak-256:
 pad `10*1`, rate 136, capacity 512) but shaped for the FFT cost model
 (width x height x log2(height)): lanes and the 25-lane state are plain
-values (no pointers, no memory traffic), the 24 rounds unroll into ONE
-permutation circuit via `fold` (one row per keccak-f call), and rotations
-are static bit recompositions (decompose once, recompose at compile-time
-offsets) instead of runtime bit lists. theta's rotl-by-1 skips
-decomposition entirely: `u8_add(b, b)` yields `(2b mod 256, msb)` and the
-even low byte absorbs the neighbor's carry with a free field add.
-
-Generated by a script (rho+pi is 24 distinct static bit wirings); the
-pi/rho wiring is asserted against the MultiStark listing at generation
-time.
+values (no pointers, no memory traffic), and the 24 rounds run as one
+SELF-RECURSIVE `keccak_round` circuit (one row per round, the round index
+selects the iota constant), so no driver circuit pays 24 call sites of
+200-column state materialization. Rotations (rho and theta's rotl-by-1)
+use the chainable `u8_chain_rotr(k, hi, lo)` byte-pair gadget: 4 chain
+lookups per lane, with the odd output bytes recombining two chain
+fragments via a free field add; multiples of 8 are free byte shuffles.
+
+The rho+pi wiring (24 distinct offsets) is generated by a script and
+asserted against a reference 64-bit rotation at generation time.
 -/
 
 public section
@@ -121,7 +121,7 @@ def keccak := ⟦
     let s = set(s, 14, [u8_xor(s[14][0], rl14[0]), u8_xor(s[14][1], rl14[1]), u8_xor(s[14][2], rl14[2]), u8_xor(s[14][3], rl14[3]), u8_xor(s[14][4], rl14[4]), u8_xor(s[14][5], rl14[5]), u8_xor(s[14][6], rl14[6]), u8_xor(s[14][7], rl14[7])]);
     let s = set(s, 15, [u8_xor(s[15][0], rl15[0]), u8_xor(s[15][1], rl15[1]), u8_xor(s[15][2], rl15[2]), u8_xor(s[15][3], rl15[3]), u8_xor(s[15][4], rl15[4]), u8_xor(s[15][5], rl15[5]), u8_xor(s[15][6], rl15[6]), u8_xor(s[15][7], rl15[7])]);
     let s = set(s, 16, [u8_xor(s[16][0], rl16[0]), u8_xor(s[16][1], rl16[1]), u8_xor(s[16][2], rl16[2]), u8_xor(s[16][3], rl16[3]), u8_xor(s[16][4], rl16[4]), u8_xor(s[16][5], rl16[5]), u8_xor(s[16][6], rl16[6]), u8_xor(s[16][7], rl16[7])]);
-    let s2 = keccak_f(s);
+    let s2 = keccak_round(s, 0);
     match fp {
       1 => absorb_blocks(st, s2),
       _ => s2,
@@ -155,103 +155,43 @@ def keccak := ⟦
     @xor8(b0, @and8(@not8(b1), b2))
   }
 
-  -- theta's rotl-by-1 of a column parity, via the u8_add doubling trick:
-  -- (b + b) = (2b mod 256, msb); the even low byte absorbs the neighbor's
-  -- msb through a free field add.
-  fn rotl1(l: [U8; 8]) -> [U8; 8] {
-    let (a0, m0) = u8_add(l[0], l[0]);
-    let (a1, m1) = u8_add(l[1], l[1]);
-    let (a2, m2) = u8_add(l[2], l[2]);
-    let (a3, m3) = u8_add(l[3], l[3]);
-    let (a4, m4) = u8_add(l[4], l[4]);
-    let (a5, m5) = u8_add(l[5], l[5]);
-    let (a6, m6) = u8_add(l[6], l[6]);
-    let (a7, m7) = u8_add(l[7], l[7]);
-    [u8_from_field_unsafe(to_field(a0) + to_field(m7)), u8_from_field_unsafe(to_field(a1) + to_field(m0)), u8_from_field_unsafe(to_field(a2) + to_field(m1)), u8_from_field_unsafe(to_field(a3) + to_field(m2)), u8_from_field_unsafe(to_field(a4) + to_field(m3)), u8_from_field_unsafe(to_field(a5) + to_field(m4)), u8_from_field_unsafe(to_field(a6) + to_field(m5)), u8_from_field_unsafe(to_field(a7) + to_field(m6))]
-  }
 
-  /- # rho rotations: one `rotl_N` per distinct offset (bit recomposition;
-     multiples of 8 are byte shuffles, others chain the u8_add / u8_shift
-     tricks). All `@`-inlined. -/
+  /- # rho rotations: one `rotl_N` per distinct offset. Bit rotations use
+     the chainable `u8_chain_rotr(k, hi, lo)` byte-pair gadget (4 chain
+     lookups per lane; the odd output bytes recombine two chain fragments
+     with a free field add); multiples of 8 are free byte shuffles. All
+     `@`-inlined. -/
 
   fn rotl_1(l: [U8; 8]) -> [U8; 8] {
-    let (a0_0, c0_0) = u8_add(l[0], l[0]);
-    let (a0_1, c0_1) = u8_add(l[1], l[1]);
-    let (a0_2, c0_2) = u8_add(l[2], l[2]);
-    let (a0_3, c0_3) = u8_add(l[3], l[3]);
-    let (a0_4, c0_4) = u8_add(l[4], l[4]);
-    let (a0_5, c0_5) = u8_add(l[5], l[5]);
-    let (a0_6, c0_6) = u8_add(l[6], l[6]);
-    let (a0_7, c0_7) = u8_add(l[7], l[7]);
-    [u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6))]
+    let (a0, b0, c0) = u8_chain_rotr(7, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(7, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(7, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(7, l[6], l[7]);
+    [u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3]
   }
 
   fn rotl_2(l: [U8; 8]) -> [U8; 8] {
-    let (a0_0, c0_0) = u8_add(l[0], l[0]);
-    let (a0_1, c0_1) = u8_add(l[1], l[1]);
-    let (a0_2, c0_2) = u8_add(l[2], l[2]);
-    let (a0_3, c0_3) = u8_add(l[3], l[3]);
-    let (a0_4, c0_4) = u8_add(l[4], l[4]);
-    let (a0_5, c0_5) = u8_add(l[5], l[5]);
-    let (a0_6, c0_6) = u8_add(l[6], l[6]);
-    let (a0_7, c0_7) = u8_add(l[7], l[7]);
-    let (a1_0, c1_0) = u8_add(u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)));
-    let (a1_1, c1_1) = u8_add(u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)));
-    let (a1_2, c1_2) = u8_add(u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)));
-    let (a1_3, c1_3) = u8_add(u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)));
-    let (a1_4, c1_4) = u8_add(u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)));
-    let (a1_5, c1_5) = u8_add(u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)));
-    let (a1_6, c1_6) = u8_add(u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)));
-    let (a1_7, c1_7) = u8_add(u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)));
-    [u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)), u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)), u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)), u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)), u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)), u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)), u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)), u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6))]
+    let (a0, b0, c0) = u8_chain_rotr(6, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(6, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(6, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(6, l[6], l[7]);
+    [u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3]
   }
 
   fn rotl_3(l: [U8; 8]) -> [U8; 8] {
-    let (a0_0, c0_0) = u8_add(l[0], l[0]);
-    let (a0_1, c0_1) = u8_add(l[1], l[1]);
-    let (a0_2, c0_2) = u8_add(l[2], l[2]);
-    let (a0_3, c0_3) = u8_add(l[3], l[3]);
-    let (a0_4, c0_4) = u8_add(l[4], l[4]);
-    let (a0_5, c0_5) = u8_add(l[5], l[5]);
-    let (a0_6, c0_6) = u8_add(l[6], l[6]);
-    let (a0_7, c0_7) = u8_add(l[7], l[7]);
-    let (a1_0, c1_0) = u8_add(u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)));
-    let (a1_1, c1_1) = u8_add(u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)));
-    let (a1_2, c1_2) = u8_add(u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)));
-    let (a1_3, c1_3) = u8_add(u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)));
-    let (a1_4, c1_4) = u8_add(u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)));
-    let (a1_5, c1_5) = u8_add(u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)));
-    let (a1_6, c1_6) = u8_add(u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)));
-    let (a1_7, c1_7) = u8_add(u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)));
-    let (a2_0, c2_0) = u8_add(u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)), u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)));
-    let (a2_1, c2_1) = u8_add(u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)), u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)));
-    let (a2_2, c2_2) = u8_add(u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)), u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)));
-    let (a2_3, c2_3) = u8_add(u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)), u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)));
-    let (a2_4, c2_4) = u8_add(u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)), u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)));
-    let (a2_5, c2_5) = u8_add(u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)), u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)));
-    let (a2_6, c2_6) = u8_add(u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)), u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)));
-    let (a2_7, c2_7) = u8_add(u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6)), u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6)));
-    [u8_from_field_unsafe(to_field(a2_0) + to_field(c2_7)), u8_from_field_unsafe(to_field(a2_1) + to_field(c2_0)), u8_from_field_unsafe(to_field(a2_2) + to_field(c2_1)), u8_from_field_unsafe(to_field(a2_3) + to_field(c2_2)), u8_from_field_unsafe(to_field(a2_4) + to_field(c2_3)), u8_from_field_unsafe(to_field(a2_5) + to_field(c2_4)), u8_from_field_unsafe(to_field(a2_6) + to_field(c2_5)), u8_from_field_unsafe(to_field(a2_7) + to_field(c2_6))]
+    let (a0, b0, c0) = u8_chain_rotr(5, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(5, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(5, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(5, l[6], l[7]);
+    [u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3]
   }
 
   fn rotl_6(l: [U8; 8]) -> [U8; 8] {
-    let h0_0 = u8_shift_right(l[7]);
-    let h0_1 = u8_shift_right(l[0]);
-    let h0_2 = u8_shift_right(l[1]);
-    let h0_3 = u8_shift_right(l[2]);
-    let h0_4 = u8_shift_right(l[3]);
-    let h0_5 = u8_shift_right(l[4]);
-    let h0_6 = u8_shift_right(l[5]);
-    let h0_7 = u8_shift_right(l[6]);
-    let h1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[0]) - 2 * to_field(h0_1))));
-    let h1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[1]) - 2 * to_field(h0_2))));
-    let h1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[2]) - 2 * to_field(h0_3))));
-    let h1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[3]) - 2 * to_field(h0_4))));
-    let h1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[4]) - 2 * to_field(h0_5))));
-    let h1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[5]) - 2 * to_field(h0_6))));
-    let h1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[6]) - 2 * to_field(h0_7))));
-    let h1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[7]) - 2 * to_field(h0_0))));
-    [u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[1]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1))), u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[2]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2))), u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[3]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3))), u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[4]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4))), u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[5]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5))), u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[6]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6))), u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[7]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7))), u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[0]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0)))]
+    let (a0, b0, c0) = u8_chain_rotr(2, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(2, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(2, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(2, l[6], l[7]);
+    [u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3]
   }
 
   fn rotl_8(l: [U8; 8]) -> [U8; 8] {
@@ -259,283 +199,131 @@ def keccak := ⟦
   }
 
   fn rotl_10(l: [U8; 8]) -> [U8; 8] {
-    let (a0_0, c0_0) = u8_add(l[7], l[7]);
-    let (a0_1, c0_1) = u8_add(l[0], l[0]);
-    let (a0_2, c0_2) = u8_add(l[1], l[1]);
-    let (a0_3, c0_3) = u8_add(l[2], l[2]);
-    let (a0_4, c0_4) = u8_add(l[3], l[3]);
-    let (a0_5, c0_5) = u8_add(l[4], l[4]);
-    let (a0_6, c0_6) = u8_add(l[5], l[5]);
-    let (a0_7, c0_7) = u8_add(l[6], l[6]);
-    let (a1_0, c1_0) = u8_add(u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)));
-    let (a1_1, c1_1) = u8_add(u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)));
-    let (a1_2, c1_2) = u8_add(u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)));
-    let (a1_3, c1_3) = u8_add(u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)));
-    let (a1_4, c1_4) = u8_add(u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)));
-    let (a1_5, c1_5) = u8_add(u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)));
-    let (a1_6, c1_6) = u8_add(u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)));
-    let (a1_7, c1_7) = u8_add(u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)));
-    [u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)), u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)), u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)), u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)), u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)), u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)), u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)), u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6))]
+    let (a0, b0, c0) = u8_chain_rotr(6, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(6, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(6, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(6, l[6], l[7]);
+    [a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3))]
   }
 
   fn rotl_14(l: [U8; 8]) -> [U8; 8] {
-    let h0_0 = u8_shift_right(l[6]);
-    let h0_1 = u8_shift_right(l[7]);
-    let h0_2 = u8_shift_right(l[0]);
-    let h0_3 = u8_shift_right(l[1]);
-    let h0_4 = u8_shift_right(l[2]);
-    let h0_5 = u8_shift_right(l[3]);
-    let h0_6 = u8_shift_right(l[4]);
-    let h0_7 = u8_shift_right(l[5]);
-    let h1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[7]) - 2 * to_field(h0_1))));
-    let h1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[0]) - 2 * to_field(h0_2))));
-    let h1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[1]) - 2 * to_field(h0_3))));
-    let h1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[2]) - 2 * to_field(h0_4))));
-    let h1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[3]) - 2 * to_field(h0_5))));
-    let h1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[4]) - 2 * to_field(h0_6))));
-    let h1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[5]) - 2 * to_field(h0_7))));
-    let h1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[6]) - 2 * to_field(h0_0))));
-    [u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[0]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1))), u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[1]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2))), u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[2]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3))), u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[3]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4))), u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[4]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5))), u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[5]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6))), u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[6]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7))), u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[7]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0)))]
+    let (a0, b0, c0) = u8_chain_rotr(2, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(2, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(2, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(2, l[6], l[7]);
+    [a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3))]
   }
 
   fn rotl_15(l: [U8; 8]) -> [U8; 8] {
-    let h0_0 = u8_shift_right(l[6]);
-    let h0_1 = u8_shift_right(l[7]);
-    let h0_2 = u8_shift_right(l[0]);
-    let h0_3 = u8_shift_right(l[1]);
-    let h0_4 = u8_shift_right(l[2]);
-    let h0_5 = u8_shift_right(l[3]);
-    let h0_6 = u8_shift_right(l[4]);
-    let h0_7 = u8_shift_right(l[5]);
-    [u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[7]) - 2 * to_field(h0_1))), u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[0]) - 2 * to_field(h0_2))), u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[1]) - 2 * to_field(h0_3))), u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[2]) - 2 * to_field(h0_4))), u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[3]) - 2 * to_field(h0_5))), u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[4]) - 2 * to_field(h0_6))), u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[5]) - 2 * to_field(h0_7))), u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[6]) - 2 * to_field(h0_0)))]
+    let (a0, b0, c0) = u8_chain_rotr(1, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(1, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(1, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(1, l[6], l[7]);
+    [a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3))]
   }
 
   fn rotl_18(l: [U8; 8]) -> [U8; 8] {
-    let (a0_0, c0_0) = u8_add(l[6], l[6]);
-    let (a0_1, c0_1) = u8_add(l[7], l[7]);
-    let (a0_2, c0_2) = u8_add(l[0], l[0]);
-    let (a0_3, c0_3) = u8_add(l[1], l[1]);
-    let (a0_4, c0_4) = u8_add(l[2], l[2]);
-    let (a0_5, c0_5) = u8_add(l[3], l[3]);
-    let (a0_6, c0_6) = u8_add(l[4], l[4]);
-    let (a0_7, c0_7) = u8_add(l[5], l[5]);
-    let (a1_0, c1_0) = u8_add(u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)));
-    let (a1_1, c1_1) = u8_add(u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)));
-    let (a1_2, c1_2) = u8_add(u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)));
-    let (a1_3, c1_3) = u8_add(u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)));
-    let (a1_4, c1_4) = u8_add(u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)));
-    let (a1_5, c1_5) = u8_add(u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)));
-    let (a1_6, c1_6) = u8_add(u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)));
-    let (a1_7, c1_7) = u8_add(u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)));
-    [u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)), u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)), u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)), u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)), u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)), u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)), u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)), u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6))]
+    let (a0, b0, c0) = u8_chain_rotr(6, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(6, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(6, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(6, l[6], l[7]);
+    [u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2]
   }
 
   fn rotl_20(l: [U8; 8]) -> [U8; 8] {
-    let d0 = u8_bit_decomposition(l[0]);
-    let d1 = u8_bit_decomposition(l[1]);
-    let d2 = u8_bit_decomposition(l[2]);
-    let d3 = u8_bit_decomposition(l[3]);
-    let d4 = u8_bit_decomposition(l[4]);
-    let d5 = u8_bit_decomposition(l[5]);
-    let d6 = u8_bit_decomposition(l[6]);
-    let d7 = u8_bit_decomposition(l[7]);
-    [u8_from_field_unsafe(d5[4] + 2 * d5[5] + 4 * d5[6] + 8 * d5[7] + 16 * d6[0] + 32 * d6[1] + 64 * d6[2] + 128 * d6[3]), u8_from_field_unsafe(d6[4] + 2 * d6[5] + 4 * d6[6] + 8 * d6[7] + 16 * d7[0] + 32 * d7[1] + 64 * d7[2] + 128 * d7[3]), u8_from_field_unsafe(d7[4] + 2 * d7[5] + 4 * d7[6] + 8 * d7[7] + 16 * d0[0] + 32 * d0[1] + 64 * d0[2] + 128 * d0[3]), u8_from_field_unsafe(d0[4] + 2 * d0[5] + 4 * d0[6] + 8 * d0[7] + 16 * d1[0] + 32 * d1[1] + 64 * d1[2] + 128 * d1[3]), u8_from_field_unsafe(d1[4] + 2 * d1[5] + 4 * d1[6] + 8 * d1[7] + 16 * d2[0] + 32 * d2[1] + 64 * d2[2] + 128 * d2[3]), u8_from_field_unsafe(d2[4] + 2 * d2[5] + 4 * d2[6] + 8 * d2[7] + 16 * d3[0] + 32 * d3[1] + 64 * d3[2] + 128 * d3[3]), u8_from_field_unsafe(d3[4] + 2 * d3[5] + 4 * d3[6] + 8 * d3[7] + 16 * d4[0] + 32 * d4[1] + 64 * d4[2] + 128 * d4[3]), u8_from_field_unsafe(d4[4] + 2 * d4[5] + 4 * d4[6] + 8 * d4[7] + 16 * d5[0] + 32 * d5[1] + 64 * d5[2] + 128 * d5[3])]
+    let (a0, b0, c0) = u8_chain_rotr(4, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(4, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(4, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(4, l[6], l[7]);
+    [u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2]
   }
 
   fn rotl_21(l: [U8; 8]) -> [U8; 8] {
-    let h0_0 = u8_shift_right(l[5]);
-    let h0_1 = u8_shift_right(l[6]);
-    let h0_2 = u8_shift_right(l[7]);
-    let h0_3 = u8_shift_right(l[0]);
-    let h0_4 = u8_shift_right(l[1]);
-    let h0_5 = u8_shift_right(l[2]);
-    let h0_6 = u8_shift_right(l[3]);
-    let h0_7 = u8_shift_right(l[4]);
-    let h1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[6]) - 2 * to_field(h0_1))));
-    let h1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[7]) - 2 * to_field(h0_2))));
-    let h1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[0]) - 2 * to_field(h0_3))));
-    let h1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[1]) - 2 * to_field(h0_4))));
-    let h1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[2]) - 2 * to_field(h0_5))));
-    let h1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[3]) - 2 * to_field(h0_6))));
-    let h1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[4]) - 2 * to_field(h0_7))));
-    let h1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[5]) - 2 * to_field(h0_0))));
-    let h2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[7]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1))));
-    let h2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[0]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2))));
-    let h2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[1]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3))));
-    let h2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[2]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4))));
-    let h2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[3]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5))));
-    let h2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[4]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6))));
-    let h2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[5]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7))));
-    let h2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[6]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0))));
-    [u8_from_field_unsafe(to_field(h2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[0]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2)))) - 2 * to_field(h2_1))), u8_from_field_unsafe(to_field(h2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[1]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3)))) - 2 * to_field(h2_2))), u8_from_field_unsafe(to_field(h2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[2]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4)))) - 2 * to_field(h2_3))), u8_from_field_unsafe(to_field(h2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[3]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5)))) - 2 * to_field(h2_4))), u8_from_field_unsafe(to_field(h2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[4]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6)))) - 2 * to_field(h2_5))), u8_from_field_unsafe(to_field(h2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[5]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7)))) - 2 * to_field(h2_6))), u8_from_field_unsafe(to_field(h2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[6]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0)))) - 2 * to_field(h2_7))), u8_from_field_unsafe(to_field(h2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[7]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1)))) - 2 * to_field(h2_0)))]
+    let (a0, b0, c0) = u8_chain_rotr(3, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(3, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(3, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(3, l[6], l[7]);
+    [u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2]
   }
 
   fn rotl_25(l: [U8; 8]) -> [U8; 8] {
-    let (a0_0, c0_0) = u8_add(l[5], l[5]);
-    let (a0_1, c0_1) = u8_add(l[6], l[6]);
-    let (a0_2, c0_2) = u8_add(l[7], l[7]);
-    let (a0_3, c0_3) = u8_add(l[0], l[0]);
-    let (a0_4, c0_4) = u8_add(l[1], l[1]);
-    let (a0_5, c0_5) = u8_add(l[2], l[2]);
-    let (a0_6, c0_6) = u8_add(l[3], l[3]);
-    let (a0_7, c0_7) = u8_add(l[4], l[4]);
-    [u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6))]
+    let (a0, b0, c0) = u8_chain_rotr(7, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(7, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(7, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(7, l[6], l[7]);
+    [a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2))]
   }
 
   fn rotl_27(l: [U8; 8]) -> [U8; 8] {
-    let (a0_0, c0_0) = u8_add(l[5], l[5]);
-    let (a0_1, c0_1) = u8_add(l[6], l[6]);
-    let (a0_2, c0_2) = u8_add(l[7], l[7]);
-    let (a0_3, c0_3) = u8_add(l[0], l[0]);
-    let (a0_4, c0_4) = u8_add(l[1], l[1]);
-    let (a0_5, c0_5) = u8_add(l[2], l[2]);
-    let (a0_6, c0_6) = u8_add(l[3], l[3]);
-    let (a0_7, c0_7) = u8_add(l[4], l[4]);
-    let (a1_0, c1_0) = u8_add(u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)));
-    let (a1_1, c1_1) = u8_add(u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)));
-    let (a1_2, c1_2) = u8_add(u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)));
-    let (a1_3, c1_3) = u8_add(u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)));
-    let (a1_4, c1_4) = u8_add(u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)));
-    let (a1_5, c1_5) = u8_add(u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)));
-    let (a1_6, c1_6) = u8_add(u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)));
-    let (a1_7, c1_7) = u8_add(u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)));
-    let (a2_0, c2_0) = u8_add(u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)), u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)));
-    let (a2_1, c2_1) = u8_add(u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)), u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)));
-    let (a2_2, c2_2) = u8_add(u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)), u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)));
-    let (a2_3, c2_3) = u8_add(u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)), u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)));
-    let (a2_4, c2_4) = u8_add(u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)), u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)));
-    let (a2_5, c2_5) = u8_add(u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)), u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)));
-    let (a2_6, c2_6) = u8_add(u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)), u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)));
-    let (a2_7, c2_7) = u8_add(u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6)), u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6)));
-    [u8_from_field_unsafe(to_field(a2_0) + to_field(c2_7)), u8_from_field_unsafe(to_field(a2_1) + to_field(c2_0)), u8_from_field_unsafe(to_field(a2_2) + to_field(c2_1)), u8_from_field_unsafe(to_field(a2_3) + to_field(c2_2)), u8_from_field_unsafe(to_field(a2_4) + to_field(c2_3)), u8_from_field_unsafe(to_field(a2_5) + to_field(c2_4)), u8_from_field_unsafe(to_field(a2_6) + to_field(c2_5)), u8_from_field_unsafe(to_field(a2_7) + to_field(c2_6))]
+    let (a0, b0, c0) = u8_chain_rotr(5, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(5, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(5, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(5, l[6], l[7]);
+    [a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2))]
   }
 
   fn rotl_28(l: [U8; 8]) -> [U8; 8] {
-    let d0 = u8_bit_decomposition(l[0]);
-    let d1 = u8_bit_decomposition(l[1]);
-    let d2 = u8_bit_decomposition(l[2]);
-    let d3 = u8_bit_decomposition(l[3]);
-    let d4 = u8_bit_decomposition(l[4]);
-    let d5 = u8_bit_decomposition(l[5]);
-    let d6 = u8_bit_decomposition(l[6]);
-    let d7 = u8_bit_decomposition(l[7]);
-    [u8_from_field_unsafe(d4[4] + 2 * d4[5] + 4 * d4[6] + 8 * d4[7] + 16 * d5[0] + 32 * d5[1] + 64 * d5[2] + 128 * d5[3]), u8_from_field_unsafe(d5[4] + 2 * d5[5] + 4 * d5[6] + 8 * d5[7] + 16 * d6[0] + 32 * d6[1] + 64 * d6[2] + 128 * d6[3]), u8_from_field_unsafe(d6[4] + 2 * d6[5] + 4 * d6[6] + 8 * d6[7] + 16 * d7[0] + 32 * d7[1] + 64 * d7[2] + 128 * d7[3]), u8_from_field_unsafe(d7[4] + 2 * d7[5] + 4 * d7[6] + 8 * d7[7] + 16 * d0[0] + 32 * d0[1] + 64 * d0[2] + 128 * d0[3]), u8_from_field_unsafe(d0[4] + 2 * d0[5] + 4 * d0[6] + 8 * d0[7] + 16 * d1[0] + 32 * d1[1] + 64 * d1[2] + 128 * d1[3]), u8_from_field_unsafe(d1[4] + 2 * d1[5] + 4 * d1[6] + 8 * d1[7] + 16 * d2[0] + 32 * d2[1] + 64 * d2[2] + 128 * d2[3]), u8_from_field_unsafe(d2[4] + 2 * d2[5] + 4 * d2[6] + 8 * d2[7] + 16 * d3[0] + 32 * d3[1] + 64 * d3[2] + 128 * d3[3]), u8_from_field_unsafe(d3[4] + 2 * d3[5] + 4 * d3[6] + 8 * d3[7] + 16 * d4[0] + 32 * d4[1] + 64 * d4[2] + 128 * d4[3])]
+    let (a0, b0, c0) = u8_chain_rotr(4, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(4, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(4, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(4, l[6], l[7]);
+    [a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2))]
   }
 
   fn rotl_36(l: [U8; 8]) -> [U8; 8] {
-    let d0 = u8_bit_decomposition(l[0]);
-    let d1 = u8_bit_decomposition(l[1]);
-    let d2 = u8_bit_decomposition(l[2]);
-    let d3 = u8_bit_decomposition(l[3]);
-    let d4 = u8_bit_decomposition(l[4]);
-    let d5 = u8_bit_decomposition(l[5]);
-    let d6 = u8_bit_decomposition(l[6]);
-    let d7 = u8_bit_decomposition(l[7]);
-    [u8_from_field_unsafe(d3[4] + 2 * d3[5] + 4 * d3[6] + 8 * d3[7] + 16 * d4[0] + 32 * d4[1] + 64 * d4[2] + 128 * d4[3]), u8_from_field_unsafe(d4[4] + 2 * d4[5] + 4 * d4[6] + 8 * d4[7] + 16 * d5[0] + 32 * d5[1] + 64 * d5[2] + 128 * d5[3]), u8_from_field_unsafe(d5[4] + 2 * d5[5] + 4 * d5[6] + 8 * d5[7] + 16 * d6[0] + 32 * d6[1] + 64 * d6[2] + 128 * d6[3]), u8_from_field_unsafe(d6[4] + 2 * d6[5] + 4 * d6[6] + 8 * d6[7] + 16 * d7[0] + 32 * d7[1] + 64 * d7[2] + 128 * d7[3]), u8_from_field_unsafe(d7[4] + 2 * d7[5] + 4 * d7[6] + 8 * d7[7] + 16 * d0[0] + 32 * d0[1] + 64 * d0[2] + 128 * d0[3]), u8_from_field_unsafe(d0[4] + 2 * d0[5] + 4 * d0[6] + 8 * d0[7] + 16 * d1[0] + 32 * d1[1] + 64 * d1[2] + 128 * d1[3]), u8_from_field_unsafe(d1[4] + 2 * d1[5] + 4 * d1[6] + 8 * d1[7] + 16 * d2[0] + 32 * d2[1] + 64 * d2[2] + 128 * d2[3]), u8_from_field_unsafe(d2[4] + 2 * d2[5] + 4 * d2[6] + 8 * d2[7] + 16 * d3[0] + 32 * d3[1] + 64 * d3[2] + 128 * d3[3])]
+    let (a0, b0, c0) = u8_chain_rotr(4, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(4, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(4, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(4, l[6], l[7]);
+    [u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1]
   }
 
   fn rotl_39(l: [U8; 8]) -> [U8; 8] {
-    let h0_0 = u8_shift_right(l[3]);
-    let h0_1 = u8_shift_right(l[4]);
-    let h0_2 = u8_shift_right(l[5]);
-    let h0_3 = u8_shift_right(l[6]);
-    let h0_4 = u8_shift_right(l[7]);
-    let h0_5 = u8_shift_right(l[0]);
-    let h0_6 = u8_shift_right(l[1]);
-    let h0_7 = u8_shift_right(l[2]);
-    [u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[4]) - 2 * to_field(h0_1))), u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[5]) - 2 * to_field(h0_2))), u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[6]) - 2 * to_field(h0_3))), u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[7]) - 2 * to_field(h0_4))), u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[0]) - 2 * to_field(h0_5))), u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[1]) - 2 * to_field(h0_6))), u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[2]) - 2 * to_field(h0_7))), u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[3]) - 2 * to_field(h0_0)))]
+    let (a0, b0, c0) = u8_chain_rotr(1, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(1, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(1, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(1, l[6], l[7]);
+    [u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1]
   }
 
   fn rotl_41(l: [U8; 8]) -> [U8; 8] {
-    let (a0_0, c0_0) = u8_add(l[3], l[3]);
-    let (a0_1, c0_1) = u8_add(l[4], l[4]);
-    let (a0_2, c0_2) = u8_add(l[5], l[5]);
-    let (a0_3, c0_3) = u8_add(l[6], l[6]);
-    let (a0_4, c0_4) = u8_add(l[7], l[7]);
-    let (a0_5, c0_5) = u8_add(l[0], l[0]);
-    let (a0_6, c0_6) = u8_add(l[1], l[1]);
-    let (a0_7, c0_7) = u8_add(l[2], l[2]);
-    [u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6))]
+    let (a0, b0, c0) = u8_chain_rotr(7, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(7, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(7, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(7, l[6], l[7]);
+    [a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1))]
   }
 
   fn rotl_43(l: [U8; 8]) -> [U8; 8] {
-    let (a0_0, c0_0) = u8_add(l[3], l[3]);
-    let (a0_1, c0_1) = u8_add(l[4], l[4]);
-    let (a0_2, c0_2) = u8_add(l[5], l[5]);
-    let (a0_3, c0_3) = u8_add(l[6], l[6]);
-    let (a0_4, c0_4) = u8_add(l[7], l[7]);
-    let (a0_5, c0_5) = u8_add(l[0], l[0]);
-    let (a0_6, c0_6) = u8_add(l[1], l[1]);
-    let (a0_7, c0_7) = u8_add(l[2], l[2]);
-    let (a1_0, c1_0) = u8_add(u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)), u8_from_field_unsafe(to_field(a0_0) + to_field(c0_7)));
-    let (a1_1, c1_1) = u8_add(u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)), u8_from_field_unsafe(to_field(a0_1) + to_field(c0_0)));
-    let (a1_2, c1_2) = u8_add(u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)), u8_from_field_unsafe(to_field(a0_2) + to_field(c0_1)));
-    let (a1_3, c1_3) = u8_add(u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)), u8_from_field_unsafe(to_field(a0_3) + to_field(c0_2)));
-    let (a1_4, c1_4) = u8_add(u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)), u8_from_field_unsafe(to_field(a0_4) + to_field(c0_3)));
-    let (a1_5, c1_5) = u8_add(u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)), u8_from_field_unsafe(to_field(a0_5) + to_field(c0_4)));
-    let (a1_6, c1_6) = u8_add(u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)), u8_from_field_unsafe(to_field(a0_6) + to_field(c0_5)));
-    let (a1_7, c1_7) = u8_add(u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)), u8_from_field_unsafe(to_field(a0_7) + to_field(c0_6)));
-    let (a2_0, c2_0) = u8_add(u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)), u8_from_field_unsafe(to_field(a1_0) + to_field(c1_7)));
-    let (a2_1, c2_1) = u8_add(u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)), u8_from_field_unsafe(to_field(a1_1) + to_field(c1_0)));
-    let (a2_2, c2_2) = u8_add(u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)), u8_from_field_unsafe(to_field(a1_2) + to_field(c1_1)));
-    let (a2_3, c2_3) = u8_add(u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)), u8_from_field_unsafe(to_field(a1_3) + to_field(c1_2)));
-    let (a2_4, c2_4) = u8_add(u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)), u8_from_field_unsafe(to_field(a1_4) + to_field(c1_3)));
-    let (a2_5, c2_5) = u8_add(u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)), u8_from_field_unsafe(to_field(a1_5) + to_field(c1_4)));
-    let (a2_6, c2_6) = u8_add(u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)), u8_from_field_unsafe(to_field(a1_6) + to_field(c1_5)));
-    let (a2_7, c2_7) = u8_add(u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6)), u8_from_field_unsafe(to_field(a1_7) + to_field(c1_6)));
-    [u8_from_field_unsafe(to_field(a2_0) + to_field(c2_7)), u8_from_field_unsafe(to_field(a2_1) + to_field(c2_0)), u8_from_field_unsafe(to_field(a2_2) + to_field(c2_1)), u8_from_field_unsafe(to_field(a2_3) + to_field(c2_2)), u8_from_field_unsafe(to_field(a2_4) + to_field(c2_3)), u8_from_field_unsafe(to_field(a2_5) + to_field(c2_4)), u8_from_field_unsafe(to_field(a2_6) + to_field(c2_5)), u8_from_field_unsafe(to_field(a2_7) + to_field(c2_6))]
+    let (a0, b0, c0) = u8_chain_rotr(5, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(5, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(5, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(5, l[6], l[7]);
+    [a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1))]
   }
 
   fn rotl_44(l: [U8; 8]) -> [U8; 8] {
-    let d0 = u8_bit_decomposition(l[0]);
-    let d1 = u8_bit_decomposition(l[1]);
-    let d2 = u8_bit_decomposition(l[2]);
-    let d3 = u8_bit_decomposition(l[3]);
-    let d4 = u8_bit_decomposition(l[4]);
-    let d5 = u8_bit_decomposition(l[5]);
-    let d6 = u8_bit_decomposition(l[6]);
-    let d7 = u8_bit_decomposition(l[7]);
-    [u8_from_field_unsafe(d2[4] + 2 * d2[5] + 4 * d2[6] + 8 * d2[7] + 16 * d3[0] + 32 * d3[1] + 64 * d3[2] + 128 * d3[3]), u8_from_field_unsafe(d3[4] + 2 * d3[5] + 4 * d3[6] + 8 * d3[7] + 16 * d4[0] + 32 * d4[1] + 64 * d4[2] + 128 * d4[3]), u8_from_field_unsafe(d4[4] + 2 * d4[5] + 4 * d4[6] + 8 * d4[7] + 16 * d5[0] + 32 * d5[1] + 64 * d5[2] + 128 * d5[3]), u8_from_field_unsafe(d5[4] + 2 * d5[5] + 4 * d5[6] + 8 * d5[7] + 16 * d6[0] + 32 * d6[1] + 64 * d6[2] + 128 * d6[3]), u8_from_field_unsafe(d6[4] + 2 * d6[5] + 4 * d6[6] + 8 * d6[7] + 16 * d7[0] + 32 * d7[1] + 64 * d7[2] + 128 * d7[3]), u8_from_field_unsafe(d7[4] + 2 * d7[5] + 4 * d7[6] + 8 * d7[7] + 16 * d0[0] + 32 * d0[1] + 64 * d0[2] + 128 * d0[3]), u8_from_field_unsafe(d0[4] + 2 * d0[5] + 4 * d0[6] + 8 * d0[7] + 16 * d1[0] + 32 * d1[1] + 64 * d1[2] + 128 * d1[3]), u8_from_field_unsafe(d1[4] + 2 * d1[5] + 4 * d1[6] + 8 * d1[7] + 16 * d2[0] + 32 * d2[1] + 64 * d2[2] + 128 * d2[3])]
+    let (a0, b0, c0) = u8_chain_rotr(4, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(4, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(4, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(4, l[6], l[7]);
+    [a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1))]
   }
 
   fn rotl_45(l: [U8; 8]) -> [U8; 8] {
-    let h0_0 = u8_shift_right(l[2]);
-    let h0_1 = u8_shift_right(l[3]);
-    let h0_2 = u8_shift_right(l[4]);
-    let h0_3 = u8_shift_right(l[5]);
-    let h0_4 = u8_shift_right(l[6]);
-    let h0_5 = u8_shift_right(l[7]);
-    let h0_6 = u8_shift_right(l[0]);
-    let h0_7 = u8_shift_right(l[1]);
-    let h1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[3]) - 2 * to_field(h0_1))));
-    let h1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[4]) - 2 * to_field(h0_2))));
-    let h1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[5]) - 2 * to_field(h0_3))));
-    let h1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[6]) - 2 * to_field(h0_4))));
-    let h1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[7]) - 2 * to_field(h0_5))));
-    let h1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[0]) - 2 * to_field(h0_6))));
-    let h1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[1]) - 2 * to_field(h0_7))));
-    let h1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[2]) - 2 * to_field(h0_0))));
-    let h2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[4]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1))));
-    let h2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[5]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2))));
-    let h2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[6]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3))));
-    let h2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[7]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4))));
-    let h2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[0]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5))));
-    let h2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[1]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6))));
-    let h2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[2]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7))));
-    let h2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[3]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0))));
-    [u8_from_field_unsafe(to_field(h2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[5]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2)))) - 2 * to_field(h2_1))), u8_from_field_unsafe(to_field(h2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[6]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3)))) - 2 * to_field(h2_2))), u8_from_field_unsafe(to_field(h2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[7]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4)))) - 2 * to_field(h2_3))), u8_from_field_unsafe(to_field(h2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[0]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5)))) - 2 * to_field(h2_4))), u8_from_field_unsafe(to_field(h2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[1]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6)))) - 2 * to_field(h2_5))), u8_from_field_unsafe(to_field(h2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[2]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7)))) - 2 * to_field(h2_6))), u8_from_field_unsafe(to_field(h2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[3]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0)))) - 2 * to_field(h2_7))), u8_from_field_unsafe(to_field(h2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[4]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1)))) - 2 * to_field(h2_0)))]
+    let (a0, b0, c0) = u8_chain_rotr(3, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(3, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(3, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(3, l[6], l[7]);
+    [a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0, u8_from_field_unsafe(to_field(b0) + to_field(c1))]
   }
 
   fn rotl_55(l: [U8; 8]) -> [U8; 8] {
-    let h0_0 = u8_shift_right(l[1]);
-    let h0_1 = u8_shift_right(l[2]);
-    let h0_2 = u8_shift_right(l[3]);
-    let h0_3 = u8_shift_right(l[4]);
-    let h0_4 = u8_shift_right(l[5]);
-    let h0_5 = u8_shift_right(l[6]);
-    let h0_6 = u8_shift_right(l[7]);
-    let h0_7 = u8_shift_right(l[0]);
-    [u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[2]) - 2 * to_field(h0_1))), u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[3]) - 2 * to_field(h0_2))), u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[4]) - 2 * to_field(h0_3))), u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[5]) - 2 * to_field(h0_4))), u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[6]) - 2 * to_field(h0_5))), u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[7]) - 2 * to_field(h0_6))), u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[0]) - 2 * to_field(h0_7))), u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[1]) - 2 * to_field(h0_0)))]
+    let (a0, b0, c0) = u8_chain_rotr(1, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(1, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(1, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(1, l[6], l[7]);
+    [u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0)), a0]
   }
 
   fn rotl_56(l: [U8; 8]) -> [U8; 8] {
@@ -543,95 +331,67 @@ def keccak := ⟦
   }
 
   fn rotl_61(l: [U8; 8]) -> [U8; 8] {
-    let h0_0 = u8_shift_right(l[0]);
-    let h0_1 = u8_shift_right(l[1]);
-    let h0_2 = u8_shift_right(l[2]);
-    let h0_3 = u8_shift_right(l[3]);
-    let h0_4 = u8_shift_right(l[4]);
-    let h0_5 = u8_shift_right(l[5]);
-    let h0_6 = u8_shift_right(l[6]);
-    let h0_7 = u8_shift_right(l[7]);
-    let h1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[1]) - 2 * to_field(h0_1))));
-    let h1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[2]) - 2 * to_field(h0_2))));
-    let h1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[3]) - 2 * to_field(h0_3))));
-    let h1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[4]) - 2 * to_field(h0_4))));
-    let h1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[5]) - 2 * to_field(h0_5))));
-    let h1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[6]) - 2 * to_field(h0_6))));
-    let h1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[7]) - 2 * to_field(h0_7))));
-    let h1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[0]) - 2 * to_field(h0_0))));
-    let h2_0 = u8_shift_right(u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[2]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1))));
-    let h2_1 = u8_shift_right(u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[3]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2))));
-    let h2_2 = u8_shift_right(u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[4]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3))));
-    let h2_3 = u8_shift_right(u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[5]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4))));
-    let h2_4 = u8_shift_right(u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[6]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5))));
-    let h2_5 = u8_shift_right(u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[7]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6))));
-    let h2_6 = u8_shift_right(u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[0]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7))));
-    let h2_7 = u8_shift_right(u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[1]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0))));
-    [u8_from_field_unsafe(to_field(h2_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[3]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2)))) - 2 * to_field(h2_1))), u8_from_field_unsafe(to_field(h2_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[4]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3)))) - 2 * to_field(h2_2))), u8_from_field_unsafe(to_field(h2_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[5]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4)))) - 2 * to_field(h2_3))), u8_from_field_unsafe(to_field(h2_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[6]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5)))) - 2 * to_field(h2_4))), u8_from_field_unsafe(to_field(h2_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[7]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6)))) - 2 * to_field(h2_5))), u8_from_field_unsafe(to_field(h2_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[0]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7)))) - 2 * to_field(h2_6))), u8_from_field_unsafe(to_field(h2_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[1]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0)))) - 2 * to_field(h2_7))), u8_from_field_unsafe(to_field(h2_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[2]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1)))) - 2 * to_field(h2_0)))]
+    let (a0, b0, c0) = u8_chain_rotr(3, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(3, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(3, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(3, l[6], l[7]);
+    [a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0))]
   }
 
   fn rotl_62(l: [U8; 8]) -> [U8; 8] {
-    let h0_0 = u8_shift_right(l[0]);
-    let h0_1 = u8_shift_right(l[1]);
-    let h0_2 = u8_shift_right(l[2]);
-    let h0_3 = u8_shift_right(l[3]);
-    let h0_4 = u8_shift_right(l[4]);
-    let h0_5 = u8_shift_right(l[5]);
-    let h0_6 = u8_shift_right(l[6]);
-    let h0_7 = u8_shift_right(l[7]);
-    let h1_0 = u8_shift_right(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[1]) - 2 * to_field(h0_1))));
-    let h1_1 = u8_shift_right(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[2]) - 2 * to_field(h0_2))));
-    let h1_2 = u8_shift_right(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[3]) - 2 * to_field(h0_3))));
-    let h1_3 = u8_shift_right(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[4]) - 2 * to_field(h0_4))));
-    let h1_4 = u8_shift_right(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[5]) - 2 * to_field(h0_5))));
-    let h1_5 = u8_shift_right(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[6]) - 2 * to_field(h0_6))));
-    let h1_6 = u8_shift_right(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[7]) - 2 * to_field(h0_7))));
-    let h1_7 = u8_shift_right(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[0]) - 2 * to_field(h0_0))));
-    [u8_from_field_unsafe(to_field(h1_0) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_1) + 128 * (to_field(l[2]) - 2 * to_field(h0_2)))) - 2 * to_field(h1_1))), u8_from_field_unsafe(to_field(h1_1) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_2) + 128 * (to_field(l[3]) - 2 * to_field(h0_3)))) - 2 * to_field(h1_2))), u8_from_field_unsafe(to_field(h1_2) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_3) + 128 * (to_field(l[4]) - 2 * to_field(h0_4)))) - 2 * to_field(h1_3))), u8_from_field_unsafe(to_field(h1_3) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_4) + 128 * (to_field(l[5]) - 2 * to_field(h0_5)))) - 2 * to_field(h1_4))), u8_from_field_unsafe(to_field(h1_4) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_5) + 128 * (to_field(l[6]) - 2 * to_field(h0_6)))) - 2 * to_field(h1_5))), u8_from_field_unsafe(to_field(h1_5) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_6) + 128 * (to_field(l[7]) - 2 * to_field(h0_7)))) - 2 * to_field(h1_6))), u8_from_field_unsafe(to_field(h1_6) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_7) + 128 * (to_field(l[0]) - 2 * to_field(h0_0)))) - 2 * to_field(h1_7))), u8_from_field_unsafe(to_field(h1_7) + 128 * (to_field(u8_from_field_unsafe(to_field(h0_0) + 128 * (to_field(l[1]) - 2 * to_field(h0_1)))) - 2 * to_field(h1_0)))]
-  }
-
-  /- # keccak-f[1600]: 24 rounds, each an inlined `@keccak_round` so all
-     24 share one circuit (one row per permutation). -/
-
-  fn keccak_f(s: [[U8; 8]; 25]) -> [[U8; 8]; 25] {
-    let s = keccak_round(s, [0x01u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_round(s, [0x82u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_round(s, [0x8au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_round(s, [0u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_round(s, [0x8bu8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_round(s, [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_round(s, [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_round(s, [0x09u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_round(s, [0x8au8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_round(s, [0x88u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_round(s, [0x09u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_round(s, [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_round(s, [0x8bu8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_round(s, [0x8bu8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_round(s, [0x89u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_round(s, [0x03u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_round(s, [0x02u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_round(s, [0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_round(s, [0x0au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let s = keccak_round(s, [0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_round(s, [0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_round(s, [0x80u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]);
-    let s = keccak_round(s, [0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8]);
-    keccak_round(s, [0x08u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8])
-  }
-
-  fn keccak_round(s: [[U8; 8]; 25], rc: [U8; 8]) -> [[U8; 8]; 25] {
+    let (a0, b0, c0) = u8_chain_rotr(2, l[0], l[1]);
+    let (a1, b1, c1) = u8_chain_rotr(2, l[2], l[3]);
+    let (a2, b2, c2) = u8_chain_rotr(2, l[4], l[5]);
+    let (a3, b3, c3) = u8_chain_rotr(2, l[6], l[7]);
+    [a0, u8_from_field_unsafe(to_field(b0) + to_field(c1)), a1, u8_from_field_unsafe(to_field(b1) + to_field(c2)), a2, u8_from_field_unsafe(to_field(b2) + to_field(c3)), a3, u8_from_field_unsafe(to_field(b3) + to_field(c0))]
+  }
+
+  /- # keccak-f[1600]: 24 rounds as ONE self-recursive circuit (one row per
+     round). The round index `i` selects the iota constant via a shared-column
+     match; recursion replaces the old 24-call `keccak_f` driver, whose call
+     sites cost 24 x (200 output aux + 1 lookup) columns. Only bytes 0, 1, 3
+     and 7 of a keccak round constant are ever non-zero, so the match yields
+     a 4-byte quad and iota xors just those four state bytes. -/
+
+  fn keccak_round(s: [[U8; 8]; 25], i: G) -> [[U8; 8]; 25] {
+    -- rc = [RC[i] byte 0, byte 1, byte 3, byte 7].
+    let rc = match i {
+      0 => [0x01u8, 0u8, 0u8, 0u8],
+      1 => [0x82u8, 0x80u8, 0u8, 0u8],
+      2 => [0x8au8, 0x80u8, 0u8, 0x80u8],
+      3 => [0u8, 0x80u8, 0x80u8, 0x80u8],
+      4 => [0x8bu8, 0x80u8, 0u8, 0u8],
+      5 => [0x01u8, 0u8, 0x80u8, 0u8],
+      6 => [0x81u8, 0x80u8, 0x80u8, 0x80u8],
+      7 => [0x09u8, 0x80u8, 0u8, 0x80u8],
+      8 => [0x8au8, 0u8, 0u8, 0u8],
+      9 => [0x88u8, 0u8, 0u8, 0u8],
+      10 => [0x09u8, 0x80u8, 0x80u8, 0u8],
+      11 => [0x0au8, 0u8, 0x80u8, 0u8],
+      12 => [0x8bu8, 0x80u8, 0x80u8, 0u8],
+      13 => [0x8bu8, 0u8, 0u8, 0x80u8],
+      14 => [0x89u8, 0x80u8, 0u8, 0x80u8],
+      15 => [0x03u8, 0x80u8, 0u8, 0x80u8],
+      16 => [0x02u8, 0x80u8, 0u8, 0x80u8],
+      17 => [0x80u8, 0u8, 0u8, 0x80u8],
+      18 => [0x0au8, 0x80u8, 0u8, 0u8],
+      19 => [0x0au8, 0u8, 0x80u8, 0x80u8],
+      20 => [0x81u8, 0x80u8, 0x80u8, 0x80u8],
+      21 => [0x80u8, 0x80u8, 0u8, 0x80u8],
+      22 => [0x01u8, 0u8, 0x80u8, 0u8],
+      _ => [0x08u8, 0x80u8, 0x80u8, 0x80u8],
+    };
     -- theta: column parities, then D[x] = C[x-1] ^ rotl1(C[x+1]).
     let c0 = @xor8(s[20], @xor8(s[15], @xor8(s[10], @xor8(s[5], s[0]))));
     let c1 = @xor8(s[21], @xor8(s[16], @xor8(s[11], @xor8(s[6], s[1]))));
     let c2 = @xor8(s[22], @xor8(s[17], @xor8(s[12], @xor8(s[7], s[2]))));
     let c3 = @xor8(s[23], @xor8(s[18], @xor8(s[13], @xor8(s[8], s[3]))));
     let c4 = @xor8(s[24], @xor8(s[19], @xor8(s[14], @xor8(s[9], s[4]))));
-    let d0 = @xor8(c4, @rotl1(c1));
-    let d1 = @xor8(c0, @rotl1(c2));
-    let d2 = @xor8(c1, @rotl1(c3));
-    let d3 = @xor8(c2, @rotl1(c4));
-    let d4 = @xor8(c3, @rotl1(c0));
+    let d0 = @xor8(c4, @rotl_1(c1));
+    let d1 = @xor8(c0, @rotl_1(c2));
+    let d2 = @xor8(c1, @rotl_1(c3));
+    let d3 = @xor8(c2, @rotl_1(c4));
+    let d4 = @xor8(c3, @rotl_1(c0));
     let t0 = @xor8(s[0], d0);
     let t1 = @xor8(s[1], d1);
     let t2 = @xor8(s[2], d2);
@@ -709,9 +469,14 @@ def keccak := ⟦
     let e22 = @chi_lane(b22, b23, b24);
     let e23 = @chi_lane(b23, b24, b20);
     let e24 = @chi_lane(b24, b20, b21);
-    -- iota.
-    let f0 = @xor8(e0, rc);
-    [f0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24]
+    -- iota: only bytes 0, 1, 3 and 7 of RC[i] can be non-zero; the rest of
+    -- the lane passes through untouched (xor with 0 is the identity).
+    let f0 = [u8_xor(e0[0], rc[0]), u8_xor(e0[1], rc[1]), e0[2], u8_xor(e0[3], rc[2]), e0[4], e0[5], e0[6], u8_xor(e0[7], rc[3])];
+    let out = [f0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24];
+    match i {
+      23 => out,
+      _ => keccak_round(out, i + 1),
+    }
   }
 ⟧
 

From 97040228ff9255688a7e89a5af2c2288bc072ff2 Mon Sep 17 00:00:00 2001
From: Arthur Paulino <arthurleonardo.ap@gmail.com>
Date: Mon, 13 Jul 2026 14:49:47 +0000
Subject: [PATCH 22/22] blake3: self-recursive compress rounds

blake3_compress_inner_j recurses on the round index, permuting the
message half between rounds and returning after round 6, so
blake3_compress pays one 128-output call site instead of seven
(1118 -> 338 columns).

512 KiB grid: total width 3173 -> 2510 (-21%), throughput unchanged.
---
 Ix/IxVM/Blake3.lean                  |   153 +-
 Tests/Ix/IxVM.lean                   |   112 +-
 crates/ixvm-codegen/src/aiur_ixvm.rs | 29756 ++++++++++++-------------
 3 files changed, 14692 insertions(+), 15329 deletions(-)

diff --git a/Ix/IxVM/Blake3.lean b/Ix/IxVM/Blake3.lean
index 5e99896f..25b243e9 100644
--- a/Ix/IxVM/Blake3.lean
+++ b/Ix/IxVM/Blake3.lean
@@ -376,7 +376,11 @@ def blake3 := ⟦
     [a, b, c, d]
   }
 
-  fn blake3_compress_inner_j(state: [[U8; 4]; 32]) -> [[U8; 4]; 32] {
+  -- One compression round per row, self-recursing over the round index:
+  -- rounds i..6, permuting the message half (state[16..31]) between rounds.
+  -- Round 6 returns without permuting. The recursion replaces seven
+  -- 128-output call sites in `blake3_compress` with a single one.
+  fn blake3_compress_inner_j(state: [[U8; 4]; 32], i: G) -> [[U8; 4]; 32] {
     -- Round 0
     let [a, b, c, d] = blake3_g_function(
       state[0], state[4], state[8], state[12], state[16], state[17]
@@ -449,7 +453,28 @@ def blake3 := ⟦
     let state = set(state, 9, c);
     let state = set(state, 14, d);
 
-    state
+    match i {
+      6 => state,
+      _ =>
+        -- Permute the message half for the next round (free byte wiring).
+        let new_state = set(state, 16, state[18]);
+        let new_state = set(new_state, 17, state[22]);
+        let new_state = set(new_state, 18, state[19]);
+        let new_state = set(new_state, 19, state[26]);
+        let new_state = set(new_state, 20, state[23]);
+        let new_state = set(new_state, 21, state[16]);
+        let new_state = set(new_state, 22, state[20]);
+        let new_state = set(new_state, 23, state[29]);
+        let new_state = set(new_state, 24, state[17]);
+        let new_state = set(new_state, 25, state[27]);
+        let new_state = set(new_state, 26, state[28]);
+        let new_state = set(new_state, 27, state[21]);
+        let new_state = set(new_state, 28, state[25]);
+        let new_state = set(new_state, 29, state[30]);
+        let new_state = set(new_state, 30, state[31]);
+        let new_state = set(new_state, 31, state[24]);
+        blake3_compress_inner_j(new_state, i + 1),
+    }
   }
 
   -- TODO:
@@ -483,128 +508,8 @@ def blake3 := ⟦
         block_words[12],   block_words[13],   block_words[14],   block_words[15]
     ];
 
-    -- Round 0
-    let state = blake3_compress_inner_j(state);
-    let new_state = set(state, 16, state[18]);
-    let new_state = set(new_state, 17, state[22]);
-    let new_state = set(new_state, 18, state[19]);
-    let new_state = set(new_state, 19, state[26]);
-    let new_state = set(new_state, 20, state[23]);
-    let new_state = set(new_state, 21, state[16]);
-    let new_state = set(new_state, 22, state[20]);
-    let new_state = set(new_state, 23, state[29]);
-    let new_state = set(new_state, 24, state[17]);
-    let new_state = set(new_state, 25, state[27]);
-    let new_state = set(new_state, 26, state[28]);
-    let new_state = set(new_state, 27, state[21]);
-    let new_state = set(new_state, 28, state[25]);
-    let new_state = set(new_state, 29, state[30]);
-    let new_state = set(new_state, 30, state[31]);
-    let new_state = set(new_state, 31, state[24]);
-    let state = new_state;
-
-    -- Round 1
-    let state = blake3_compress_inner_j(state);
-    let new_state = set(state, 16, state[18]);
-    let new_state = set(new_state, 17, state[22]);
-    let new_state = set(new_state, 18, state[19]);
-    let new_state = set(new_state, 19, state[26]);
-    let new_state = set(new_state, 20, state[23]);
-    let new_state = set(new_state, 21, state[16]);
-    let new_state = set(new_state, 22, state[20]);
-    let new_state = set(new_state, 23, state[29]);
-    let new_state = set(new_state, 24, state[17]);
-    let new_state = set(new_state, 25, state[27]);
-    let new_state = set(new_state, 26, state[28]);
-    let new_state = set(new_state, 27, state[21]);
-    let new_state = set(new_state, 28, state[25]);
-    let new_state = set(new_state, 29, state[30]);
-    let new_state = set(new_state, 30, state[31]);
-    let new_state = set(new_state, 31, state[24]);
-    let state = new_state;
-
-    -- Round 2
-    let state = blake3_compress_inner_j(state);
-    let new_state = set(state, 16, state[18]);
-    let new_state = set(new_state, 17, state[22]);
-    let new_state = set(new_state, 18, state[19]);
-    let new_state = set(new_state, 19, state[26]);
-    let new_state = set(new_state, 20, state[23]);
-    let new_state = set(new_state, 21, state[16]);
-    let new_state = set(new_state, 22, state[20]);
-    let new_state = set(new_state, 23, state[29]);
-    let new_state = set(new_state, 24, state[17]);
-    let new_state = set(new_state, 25, state[27]);
-    let new_state = set(new_state, 26, state[28]);
-    let new_state = set(new_state, 27, state[21]);
-    let new_state = set(new_state, 28, state[25]);
-    let new_state = set(new_state, 29, state[30]);
-    let new_state = set(new_state, 30, state[31]);
-    let new_state = set(new_state, 31, state[24]);
-    let state = new_state;
-
-    -- Round 3
-    let state = blake3_compress_inner_j(state);
-    let new_state = set(state, 16, state[18]);
-    let new_state = set(new_state, 17, state[22]);
-    let new_state = set(new_state, 18, state[19]);
-    let new_state = set(new_state, 19, state[26]);
-    let new_state = set(new_state, 20, state[23]);
-    let new_state = set(new_state, 21, state[16]);
-    let new_state = set(new_state, 22, state[20]);
-    let new_state = set(new_state, 23, state[29]);
-    let new_state = set(new_state, 24, state[17]);
-    let new_state = set(new_state, 25, state[27]);
-    let new_state = set(new_state, 26, state[28]);
-    let new_state = set(new_state, 27, state[21]);
-    let new_state = set(new_state, 28, state[25]);
-    let new_state = set(new_state, 29, state[30]);
-    let new_state = set(new_state, 30, state[31]);
-    let new_state = set(new_state, 31, state[24]);
-    let state = new_state;
-
-    -- Round 4
-    let state = blake3_compress_inner_j(state);
-    let new_state = set(state, 16, state[18]);
-    let new_state = set(new_state, 17, state[22]);
-    let new_state = set(new_state, 18, state[19]);
-    let new_state = set(new_state, 19, state[26]);
-    let new_state = set(new_state, 20, state[23]);
-    let new_state = set(new_state, 21, state[16]);
-    let new_state = set(new_state, 22, state[20]);
-    let new_state = set(new_state, 23, state[29]);
-    let new_state = set(new_state, 24, state[17]);
-    let new_state = set(new_state, 25, state[27]);
-    let new_state = set(new_state, 26, state[28]);
-    let new_state = set(new_state, 27, state[21]);
-    let new_state = set(new_state, 28, state[25]);
-    let new_state = set(new_state, 29, state[30]);
-    let new_state = set(new_state, 30, state[31]);
-    let new_state = set(new_state, 31, state[24]);
-    let state = new_state;
-
-    -- Round 5
-    let state = blake3_compress_inner_j(state);
-    let new_state = set(state, 16, state[18]);
-    let new_state = set(new_state, 17, state[22]);
-    let new_state = set(new_state, 18, state[19]);
-    let new_state = set(new_state, 19, state[26]);
-    let new_state = set(new_state, 20, state[23]);
-    let new_state = set(new_state, 21, state[16]);
-    let new_state = set(new_state, 22, state[20]);
-    let new_state = set(new_state, 23, state[29]);
-    let new_state = set(new_state, 24, state[17]);
-    let new_state = set(new_state, 25, state[27]);
-    let new_state = set(new_state, 26, state[28]);
-    let new_state = set(new_state, 27, state[21]);
-    let new_state = set(new_state, 28, state[25]);
-    let new_state = set(new_state, 29, state[30]);
-    let new_state = set(new_state, 30, state[31]);
-    let new_state = set(new_state, 31, state[24]);
-    let state = new_state;
-
-    -- Round 6
-    let state = blake3_compress_inner_j(state);
+    -- All 7 rounds run inside the self-recursive round circuit.
+    let state = blake3_compress_inner_j(state, 0);
 
     [
       [u8_xor(state[0][0], state[8][0]), u8_xor(state[0][1], state[8][1]), u8_xor(state[0][2], state[8][2]), u8_xor(state[0][3], state[8][3])],
diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean
index 0594adeb..c41bdb01 100644
--- a/Tests/Ix/IxVM.lean
+++ b/Tests/Ix/IxVM.lean
@@ -143,62 +143,62 @@ 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_707_330),
-  ("HEq.rec",                                                            2_674_401),
-  ("Eq.rec",                                                             2_568_796),
-  ("Nat",                                                                1_848_963),
-  ("Nat.add",                                                            12_862_667),
-  ("Nat.add_comm",                                                       53_748_034),
-  ("Nat.decEq",                                                          67_465_767),
-  ("Nat.decLe",                                                          188_267_204),
-  ("Nat.sub_le_of_le_add",                                               509_275_238),
+  ("HEq",                                                                1_552_849),
+  ("HEq.rec",                                                            2_474_182),
+  ("Eq.rec",                                                             2_372_221),
+  ("Nat",                                                                1_687_998),
+  ("Nat.add",                                                            12_150_301),
+  ("Nat.add_comm",                                                       51_137_036),
+  ("Nat.decEq",                                                          64_402_796),
+  ("Nat.decLe",                                                          179_975_464),
+  ("Nat.sub_le_of_le_add",                                               487_340_495),
   -- Newly-unlocked targets (level_leq Géran normalize).
-  ("Trans.mk",                                                           2_837_043),
-  ("Array.append_assoc",                                                 2_516_757_878),
-  ("Vector.append",                                                      2_584_871_352),
+  ("Trans.mk",                                                           2_642_891),
+  ("Array.append_assoc",                                                 2_423_215_250),
+  ("Vector.append",                                                      2_488_272_734),
   -- Primitive reduction theorems (`IxVMPrim`)
-  ("IxVMPrim.nat_add_lit",                                               27_531_135),
-  ("IxVMPrim.nat_sub_lit",                                               33_267_046),
-  ("IxVMPrim.nat_mul_lit",                                               24_330_411),
-  ("IxVMPrim.nat_mul_big",                                               23_774_792),
-  ("IxVMPrim.nat_div_lit",                                               362_408_942),
-  ("IxVMPrim.nat_mod_lit",                                               370_619_545),
-  ("IxVMPrim.nat_succ_lit",                                              7_194_844),
-  ("IxVMPrim.nat_pred_lit",                                              14_467_396),
-  ("IxVMPrim.nat_gcd_lit",                                               596_843_893),
-  ("IxVMPrim.nat_land_lit",                                              1_004_836_787),
-  ("IxVMPrim.nat_lor_lit",                                               1_005_550_176),
-  ("IxVMPrim.nat_xor_lit",                                               1_013_521_624),
-  ("IxVMPrim.nat_shl_lit",                                               34_288_792),
-  ("IxVMPrim.nat_shr_lit",                                               367_333_879),
-  ("IxVMPrim.nat_pow_big",                                                71_103_729),
-  ("IxVMPrim.nat_beq_lit",                                               23_785_738),
-  ("IxVMPrim.nat_ble_lit",                                               22_079_774),
-  ("IxVMPrim.nat_dec_le",                                                194_603_173),
-  ("IxVMPrim.nat_dec_lt",                                                198_521_364),
-  ("IxVMPrim.nat_dec_eq",                                                80_906_449),
-  ("IxVMPrim.str_size_lit",                                              709_617_199),
-  ("IxVMPrim.bv_to_nat_lit",                                             568_367_655),
+  ("IxVMPrim.nat_add_lit",                                               26_123_851),
+  ("IxVMPrim.nat_sub_lit",                                               31_552_743),
+  ("IxVMPrim.nat_mul_lit",                                               23_036_282),
+  ("IxVMPrim.nat_mul_big",                                               22_510_469),
+  ("IxVMPrim.nat_div_lit",                                               346_661_916),
+  ("IxVMPrim.nat_mod_lit",                                               354_484_174),
+  ("IxVMPrim.nat_succ_lit",                                              6_747_414),
+  ("IxVMPrim.nat_pred_lit",                                              13_651_268),
+  ("IxVMPrim.nat_gcd_lit",                                               570_853_350),
+  ("IxVMPrim.nat_land_lit",                                              960_638_159),
+  ("IxVMPrim.nat_lor_lit",                                               961_314_948),
+  ("IxVMPrim.nat_xor_lit",                                               968_938_904),
+  ("IxVMPrim.nat_shl_lit",                                               32_506_634),
+  ("IxVMPrim.nat_shr_lit",                                               351_328_442),
+  ("IxVMPrim.nat_pow_big",                                                68_467_322),
+  ("IxVMPrim.nat_beq_lit",                                               22_546_374),
+  ("IxVMPrim.nat_ble_lit",                                               20_924_235),
+  ("IxVMPrim.nat_dec_le",                                                186_026_247),
+  ("IxVMPrim.nat_dec_lt",                                                189_753_848),
+  ("IxVMPrim.nat_dec_eq",                                                77_217_821),
+  ("IxVMPrim.str_size_lit",                                              678_357_195),
+  ("IxVMPrim.bv_to_nat_lit",                                             543_611_944),
   -- Mutual block + multi-member recursors
-  ("IxVMInd.Even",                                                       25_516_962),
-  ("IxVMInd.Odd",                                                        25_269_345),
-  ("IxVMInd.Even.rec",                                                   31_116_602),
-  ("IxVMInd.Odd.rec",                                                    31_114_086),
+  ("IxVMInd.Even",                                                       24_203_913),
+  ("IxVMInd.Odd",                                                        23_969_822),
+  ("IxVMInd.Even.rec",                                                   29_529_468),
+  ("IxVMInd.Odd.rec",                                                    29_526_693),
   -- Nested inductive + aux recursor (Tree.mk : List Tree → Tree)
-  ("IxVMInd.Tree",                                                       2_607_720),
-  ("IxVMInd.Tree.rec",                                                   4_849_613),
+  ("IxVMInd.Tree",                                                       2_406_328),
+  ("IxVMInd.Tree.rec",                                                   4_537_861),
   -- Aux dedup: distinct spec_params on one external inductive (3 motives).
-  ("IxVMInd.DedupM",                                                     4_721_332),
-  ("IxVMInd.DedupM.rec",                                                 7_890_218),
+  ("IxVMInd.DedupM",                                                     4_408_804),
+  ("IxVMInd.DedupM.rec",                                                 7_425_735),
   -- Aux dedup de-lift guard: equal spec_params at field depths 0 and 2.
-  ("IxVMInd.DepthM",                                                     3_555_297),
-  ("IxVMInd.DepthM.rec",                                                 6_263_860),
+  ("IxVMInd.DepthM",                                                     3_305_630),
+  ("IxVMInd.DepthM.rec",                                                 5_884_563),
   -- Edge cases from prelude
-  ("String.Internal.append",                                             701_785_005),
-  ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec",         1_054_962_285),
+  ("String.Internal.append",                                             670_980_760),
+  ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec",         1_008_618_763),
   -- Aux recursor with transitively-nested inductives (Syntax → Array Syntax
   -- → List Syntax); shard 53 regression driver.
-  ("Lean.Syntax.rec",                                                    727_050_101),
+  ("Lean.Syntax.rec",                                                    695_219_318),
   -- Evaporated-aux canonicalization (Tests/Ix/Compile/Mutual.lean AuxDedup*):
   -- SCC splitting strands `rec_N` auxes whose spec-param inductives moved to
   -- other SCCs; their claims alias the external inductive's recursor
@@ -206,15 +206,15 @@ private def kernelCheckEntries : List (String × Nat) := [
   -- whose claims are literally the same `List.rec` closure. AuxDedupMixed
   -- mixes one genuine canonical aux (`M.rec_1`, over `List M`) with one
   -- evaporated alias (`M.rec_2`, over `List B`).
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A",             3_498_075),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec",         4_390_037),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1",       3_087_145),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2",       3_087_145),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1",       3_087_145),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M",         3_531_908),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec",     6_150_929),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1",   6_152_908),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2",   3_087_145),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A",             3_247_137),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec",         4_091_451),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1",       2_863_484),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2",       2_863_484),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1",       2_863_484),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M",         3_280_886),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec",     5_769_906),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1",   5_771_906),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2",   2_863_484),
 ]
 
 private def nameOfString (str : String) : Lean.Name :=
diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs
index f43c37cb..ea71db8a 100644
--- a/crates/ixvm-codegen/src/aiur_ixvm.rs
+++ b/crates/ixvm-codegen/src/aiur_ixvm.rs
@@ -14,7 +14,7 @@
 
 use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
 use aiur::G;
-use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_and_value, bytes2_or_value, bytes2_less_than_value, bytes2_add_value, bytes2_sub_value, bytes2_chain_rotr7_value, bytes2_chain_rotr4_value, unconstrained_big_uint_div_mod_helper, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 };
+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_rotr_value, unconstrained_big_uint_div_mod_helper, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 };
 
 const INPUT_SIZE_0: usize = 3;
 const IN_0: usize = 3;
@@ -1504,71 +1504,15 @@ fn aiur_fn_3(
   })
 }
 
-const INPUT_SIZE_4: usize = 8;
-const IN_4: usize = 8;
-const OUT_4: usize = 4;
+const INPUT_SIZE_4: usize = 16;
+const IN_4: usize = 16;
+const OUT_4: usize = 1;
 fn aiur_fn_4(
   inp: [G; IN_4],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_4], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = if unconstrained { Bytes2::xor(&__v_0, &__v_4) } else { bytes2_xor_value(__v_0, __v_4, record) };
-    let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) };
-    let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) };
-    let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) };
-    let __ret: [G; OUT_4] = [__v_8, __v_9, __v_10, __v_11];
-    record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_5: usize = 8;
-const IN_5: usize = 8;
-const OUT_5: usize = 4;
-fn aiur_fn_5(
-  inp: [G; IN_5],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_5], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = if unconstrained { Bytes2::and(&__v_0, &__v_4) } else { bytes2_and_value(__v_0, __v_4, record) };
-    let __v_9: G = if unconstrained { Bytes2::and(&__v_1, &__v_5) } else { bytes2_and_value(__v_1, __v_5, record) };
-    let __v_10: G = if unconstrained { Bytes2::and(&__v_2, &__v_6) } else { bytes2_and_value(__v_2, __v_6, record) };
-    let __v_11: G = if unconstrained { Bytes2::and(&__v_3, &__v_7) } else { bytes2_and_value(__v_3, __v_7, record) };
-    let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11];
-    record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_6: usize = 16;
-const IN_6: usize = 16;
-const OUT_6: usize = 1;
-fn aiur_fn_6(
-  inp: [G; IN_6],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_6], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1611,85 +1555,85 @@ fn aiur_fn_6(
                                 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));
+                                    let __ret: [G; OUT_4] = [__v_24];
+                                    record.function_queries[4].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));
+                                    let __ret: [G; OUT_4] = [__v_24];
+                                    record.function_queries[4].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));
+                                let __ret: [G; OUT_4] = [__v_24];
+                                record.function_queries[4].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));
+                            let __ret: [G; OUT_4] = [__v_24];
+                            record.function_queries[4].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));
+                        let __ret: [G; OUT_4] = [__v_24];
+                        record.function_queries[4].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));
+                    let __ret: [G; OUT_4] = [__v_24];
+                    record.function_queries[4].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));
+                let __ret: [G; OUT_4] = [__v_24];
+                record.function_queries[4].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));
+            let __ret: [G; OUT_4] = [__v_24];
+            record.function_queries[4].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));
+        let __ret: [G; OUT_4] = [__v_24];
+        record.function_queries[4].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],
+const INPUT_SIZE_5: usize = 16;
+const IN_5: usize = 16;
+const OUT_5: usize = 9;
+fn aiur_fn_5(
+  inp: [G; IN_5],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_7], ExecError> {
+) -> Result<[G; OUT_5], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1759,21 +1703,21 @@ fn aiur_fn_7(
     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));
+    let __ret: [G; OUT_5] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
+    record.function_queries[5].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],
+const INPUT_SIZE_6: usize = 16;
+const IN_6: usize = 16;
+const OUT_6: usize = 8;
+fn aiur_fn_6(
+  inp: [G; IN_6],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_8], ExecError> {
+) -> Result<[G; OUT_6], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1795,12 +1739,12 @@ fn aiur_fn_8(
     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));
+        let __ret: [G; OUT_6] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_17: G = __r_arr[0];
         let __v_18: G = __r_arr[1];
         let __v_19: G = __r_arr[2];
@@ -1809,7 +1753,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; 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 __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_25: G = __r_arr[0];
         let __v_26: G = __r_arr[1];
         let __v_27: G = __r_arr[2];
@@ -1818,7 +1762,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; 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 __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_17, __v_18, __v_19, __v_20, __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[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_33: G = __r_arr[0];
         let __v_34: G = __r_arr[1];
         let __v_35: G = __r_arr[2];
@@ -1827,8 +1771,8 @@ fn aiur_fn_8(
         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));
+        let __ret: [G; OUT_6] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40];
+        record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -1838,15 +1782,15 @@ fn aiur_fn_8(
   })
 }
 
-const INPUT_SIZE_9: usize = 2;
-const IN_9: usize = 2;
-const OUT_9: usize = 1;
-fn aiur_fn_9(
-  inp: [G; IN_9],
+const INPUT_SIZE_7: usize = 2;
+const IN_7: usize = 2;
+const OUT_7: usize = 1;
+fn aiur_fn_7(
+  inp: [G; IN_7],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_9], ExecError> {
+) -> Result<[G; OUT_7], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1855,37 +1799,37 @@ fn aiur_fn_9(
         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));
+            let __ret: [G; OUT_7] = [__v_2];
+            record.function_queries[7].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));
+            let __ret: [G; OUT_7] = [__v_2];
+            record.function_queries[7].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));
+        let __ret: [G; OUT_7] = [__v_2];
+        record.function_queries[7].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],
+const INPUT_SIZE_8: usize = 8;
+const IN_8: usize = 8;
+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_10], ExecError> {
+) -> Result<[G; OUT_8], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1919,8 +1863,8 @@ fn aiur_fn_10(
                                     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));
+                                    let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -1933,8 +1877,8 @@ fn aiur_fn_10(
                                     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));
+                                    let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -1948,8 +1892,8 @@ fn aiur_fn_10(
                                 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));
+                                let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1962,8 +1906,8 @@ fn aiur_fn_10(
                             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));
+                            let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -1975,8 +1919,8 @@ fn aiur_fn_10(
                         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));
+                        let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -1987,8 +1931,8 @@ fn aiur_fn_10(
                     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));
+                    let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -1998,8 +1942,8 @@ fn aiur_fn_10(
                 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));
+                let __ret: [G; OUT_8] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -2008,8 +1952,8 @@ fn aiur_fn_10(
             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));
+            let __ret: [G; OUT_8] = [__v_8, __v_10, __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);
           },
         }
@@ -2017,23 +1961,23 @@ fn aiur_fn_10(
       _ => {
         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));
+        let __ret: [G; OUT_8] = [__v_9, __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);
       },
     }
   })
 }
 
-const INPUT_SIZE_11: usize = 10;
-const IN_11: usize = 10;
-const OUT_11: usize = 8;
-fn aiur_fn_11(
-  inp: [G; IN_11],
+const INPUT_SIZE_9: usize = 10;
+const IN_9: usize = 10;
+const OUT_9: usize = 8;
+fn aiur_fn_9(
+  inp: [G; IN_9],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_11], ExecError> {
+) -> Result<[G; OUT_9], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2073,68 +2017,21 @@ fn aiur_fn_11(
     let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_26) } else { bytes2_add_value(__v_0, __v_26, record) };
     let __v_27: G = __b2_add.0;
     let __v_28: G = __b2_add.1;
-    let __ret: [G; OUT_11] = [__v_27, __v_25, __v_23, __v_21, __v_19, __v_17, __v_12, __v_10];
-    record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_9] = [__v_27, __v_25, __v_23, __v_21, __v_19, __v_17, __v_14, __v_10];
+    record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_12: usize = 8;
-const IN_12: usize = 8;
-const OUT_12: usize = 4;
-fn aiur_fn_12(
-  inp: [G; IN_12],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_12], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_7) } else { bytes2_add_value(__v_3, __v_7, record) };
-    let __v_8: G = __b2_add.0;
-    let __v_9: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) };
-    let __v_10: G = __b2_add.0;
-    let __v_11: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_10, &__v_9) } else { bytes2_add_value(__v_10, __v_9, record) };
-    let __v_12: G = __b2_add.0;
-    let __v_13: G = __b2_add.1;
-    let __v_14: G = (__v_11 + __v_13);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) };
-    let __v_15: G = __b2_add.0;
-    let __v_16: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_15, &__v_14) } else { bytes2_add_value(__v_15, __v_14, record) };
-    let __v_17: G = __b2_add.0;
-    let __v_18: G = __b2_add.1;
-    let __v_19: G = (__v_16 + __v_18);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_4) } else { bytes2_add_value(__v_0, __v_4, record) };
-    let __v_20: G = __b2_add.0;
-    let __v_21: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_20, &__v_19) } else { bytes2_add_value(__v_20, __v_19, record) };
-    let __v_22: G = __b2_add.0;
-    let __v_23: G = __b2_add.1;
-    let __ret: [G; OUT_12] = [__v_22, __v_17, __v_12, __v_8];
-    record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_13: usize = 8;
-const IN_13: usize = 8;
-const OUT_13: usize = 8;
-fn aiur_fn_13(
-  inp: [G; IN_13],
+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_13], ExecError> {
+) -> Result<[G; OUT_10], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2168,8 +2065,8 @@ fn aiur_fn_13(
                                     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));
+                                    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);
                                   },
                                   _ => {
@@ -2182,8 +2079,8 @@ fn aiur_fn_13(
                                     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));
+                                    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);
                                   },
                                 }
@@ -2197,8 +2094,8 @@ fn aiur_fn_13(
                                 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));
+                                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);
                               },
                             }
@@ -2211,8 +2108,8 @@ fn aiur_fn_13(
                             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));
+                            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);
                           },
                         }
@@ -2224,8 +2121,8 @@ fn aiur_fn_13(
                         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));
+                        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);
                       },
                     }
@@ -2236,8 +2133,8 @@ fn aiur_fn_13(
                     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));
+                    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);
                   },
                 }
@@ -2247,8 +2144,8 @@ fn aiur_fn_13(
                 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));
+                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);
               },
             }
@@ -2257,8 +2154,8 @@ fn aiur_fn_13(
             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));
+            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);
           },
         }
@@ -2266,23 +2163,23 @@ fn aiur_fn_13(
       _ => {
         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));
+        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_14: usize = 8;
-const IN_14: usize = 8;
-const OUT_14: usize = 1;
-fn aiur_fn_14(
-  inp: [G; IN_14],
+const INPUT_SIZE_11: usize = 8;
+const IN_11: usize = 8;
+const OUT_11: usize = 1;
+fn aiur_fn_11(
+  inp: [G; IN_11],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_14], ExecError> {
+) -> Result<[G; OUT_11], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2314,21 +2211,21 @@ fn aiur_fn_14(
     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));
+    let __ret: [G; OUT_11] = [__v_26];
+    record.function_queries[11].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],
+const INPUT_SIZE_12: usize = 0;
+const IN_12: usize = 0;
+const OUT_12: usize = 32;
+fn aiur_fn_12(
+  inp: [G; IN_12],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_15], ExecError> {
+) -> Result<[G; OUT_12], 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);
@@ -2338,7 +2235,7 @@ fn aiur_fn_15(
     let __v_4: G = G::from_u64(0);
     let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_2, __v_3]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_5]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     let __v_8: G = __r_arr[2];
@@ -2371,21 +2268,21 @@ fn aiur_fn_15(
     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));
+    let __ret: [G; OUT_12] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __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[12].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],
+const INPUT_SIZE_13: usize = 1;
+const IN_13: usize = 1;
+const OUT_13: usize = 1;
+fn aiur_fn_13(
+  inp: [G; IN_13],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_16], ExecError> {
+) -> Result<[G; OUT_13], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(1);
@@ -2397,7 +2294,7 @@ fn aiur_fn_16(
     let __v_6: G = G::from_u64(0);
     let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7]; 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_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
     let __v_10: G = __r_arr[2];
@@ -2433,30 +2330,30 @@ fn aiur_fn_16(
     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));
+        let __ret: [G; OUT_13] = [__v_40];
+        record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2]; 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_40: G = __r_arr[0];
-        let __ret: [G; OUT_16] = [__v_40];
-        record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_13] = [__v_40];
+        record.function_queries[13].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],
+const INPUT_SIZE_14: usize = 1;
+const IN_14: usize = 1;
+const OUT_14: usize = 32;
+fn aiur_fn_14(
+  inp: [G; IN_14],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_17], ExecError> {
+) -> Result<[G; OUT_14], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
@@ -2509,7 +2406,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_22] = { let __args: [G; IN_22] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; 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 __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
     let __v_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];
@@ -2546,7 +2443,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_21] = { let __args: [G; IN_21] = [__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[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 __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_86: G = __r_arr[0];
     let __v_87: G = __r_arr[1];
     let __v_88: G = __r_arr[2];
@@ -2579,21 +2476,21 @@ fn aiur_fn_17(
     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));
+    let __ret: [G; OUT_14] = [__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[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_18: usize = 33;
-const IN_18: usize = 33;
-const OUT_18: usize = 0;
-fn aiur_fn_18(
-  inp: [G; IN_18],
+const INPUT_SIZE_15: usize = 33;
+const IN_15: usize = 33;
+const OUT_15: usize = 0;
+fn aiur_fn_15(
+  inp: [G; IN_15],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_18], ExecError> {
+) -> Result<[G; OUT_15], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2628,7 +2525,7 @@ fn aiur_fn_18(
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
     let __v_32: G = inp[32];
-    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 __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_0]; 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_33: G = __r_arr[0];
     let __v_34: G = __r_arr[1];
     let __v_35: G = __r_arr[2];
@@ -2757,24 +2654,24 @@ fn aiur_fn_18(
     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_18] = [];
-    record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_15] = [];
+    record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_19: usize = 1;
-const IN_19: usize = 1;
-const OUT_19: usize = 1;
-fn aiur_fn_19(
-  inp: [G; IN_19],
+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_19], ExecError> {
+) -> Result<[G; OUT_16], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_0]; 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -2808,21 +2705,21 @@ fn aiur_fn_19(
     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_19] = [__v_33];
-    record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_16] = [__v_33];
+    record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_20: usize = 67;
-const IN_20: usize = 67;
-const OUT_20: usize = 67;
-fn aiur_fn_20(
-  inp: [G; IN_20],
+const INPUT_SIZE_17: usize = 67;
+const IN_17: usize = 67;
+const OUT_17: usize = 67;
+fn aiur_fn_17(
+  inp: [G; IN_17],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_20], ExecError> {
+) -> Result<[G; OUT_17], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2896,8 +2793,8 @@ fn aiur_fn_20(
         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_20] = [__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[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_17] = [__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[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -2937,7 +2834,7 @@ fn aiur_fn_20(
         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_20] = { let __args: [G; IN_20] = [__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[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 __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[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_102: G = __r_arr[0];
         let __v_103: G = __r_arr[1];
         let __v_104: G = __r_arr[2];
@@ -3008,8 +2905,8 @@ fn aiur_fn_20(
         match __v_102.as_canonical_u64() {
           0u64 => {
             let __v_169: G = G::from_u64(1);
-            let __ret: [G; OUT_20] = [__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[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_17] = [__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[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
@@ -3060,7 +2957,7 @@ fn aiur_fn_20(
                 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_29] = { let __args: [G; IN_29] = [__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[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 __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__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[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_214: G = __r_arr[0];
                 let __v_215: G = __r_arr[1];
                 let __v_216: G = __r_arr[2];
@@ -3097,8 +2994,8 @@ fn aiur_fn_20(
                 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_20] = [__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[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_17] = [__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[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -3111,7 +3008,7 @@ fn aiur_fn_20(
                 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_29] = { let __args: [G; IN_29] = [__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[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 __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__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[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_212: G = __r_arr[0];
                 let __v_213: G = __r_arr[1];
                 let __v_214: G = __r_arr[2];
@@ -3148,8 +3045,8 @@ fn aiur_fn_20(
                 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_20] = [__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[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_17] = [__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[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -3166,15 +3063,15 @@ fn aiur_fn_20(
   })
 }
 
-const INPUT_SIZE_21: usize = 34;
-const IN_21: usize = 34;
-const OUT_21: usize = 32;
-fn aiur_fn_21(
-  inp: [G; IN_21],
+const INPUT_SIZE_18: usize = 34;
+const IN_18: usize = 34;
+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_21], ExecError> {
+) -> Result<[G; OUT_18], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -3249,8 +3146,8 @@ fn aiur_fn_21(
         let __v_67: G = __loaded[33];
         match __v_34.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_21] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __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[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_18] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __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[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -3290,7 +3187,7 @@ fn aiur_fn_21(
             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_20] = { let __args: [G; IN_20] = [__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[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 __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[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_103: G = __r_arr[0];
             let __v_104: G = __r_arr[1];
             let __v_105: G = __r_arr[2];
@@ -3360,7 +3257,7 @@ fn aiur_fn_21(
             let __v_169: G = __r_arr[66];
             match __v_103.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__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[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 __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_170: G = __r_arr[0];
                 let __v_171: G = __r_arr[1];
                 let __v_172: G = __r_arr[2];
@@ -3393,14 +3290,14 @@ fn aiur_fn_21(
                 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_21] = [__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[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_18] = [__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[18].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_21] = { let __args: [G; IN_21] = [__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[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 __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_172: G = __r_arr[0];
                 let __v_173: G = __r_arr[1];
                 let __v_174: G = __r_arr[2];
@@ -3433,8 +3330,8 @@ fn aiur_fn_21(
                 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_21] = [__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[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_18] = [__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[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -3451,15 +3348,15 @@ fn aiur_fn_21(
   })
 }
 
-const INPUT_SIZE_22: usize = 7;
-const IN_22: usize = 7;
-const OUT_22: usize = 1;
-fn aiur_fn_22(
-  inp: [G; IN_22],
+const INPUT_SIZE_19: usize = 7;
+const IN_19: usize = 7;
+const OUT_19: usize = 1;
+fn aiur_fn_19(
+  inp: [G; IN_19],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_22], ExecError> {
+) -> Result<[G; OUT_19], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -3474,10 +3371,10 @@ fn aiur_fn_22(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_1, __v_2, __v_3, __v_4, __v_5, __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 __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_22] = [__v_10];
-        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_19] = [__v_10];
+        record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -3485,10 +3382,10 @@ fn aiur_fn_22(
         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_26] = { let __args: [G; IN_26] = [__v_9, __v_11, __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 __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_9, __v_11, __v_3, __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_12: G = __r_arr[0];
-            let __ret: [G; OUT_22] = [__v_12];
-            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_19] = [__v_12];
+            record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -3496,10 +3393,10 @@ fn aiur_fn_22(
             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_22] = { let __args: [G; IN_22] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
-            let __ret: [G; OUT_22] = [__v_16];
-            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_19] = [__v_16];
+            record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -3511,15 +3408,15 @@ fn aiur_fn_22(
   })
 }
 
-const INPUT_SIZE_23: usize = 1;
-const IN_23: usize = 1;
-const OUT_23: usize = 64;
-fn aiur_fn_23(
-  inp: [G; IN_23],
+const INPUT_SIZE_20: usize = 1;
+const IN_20: usize = 1;
+const OUT_20: usize = 64;
+fn aiur_fn_20(
+  inp: [G; IN_20],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_23], ExecError> {
+) -> Result<[G; OUT_20], 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 };
@@ -3906,8 +3803,8 @@ fn aiur_fn_23(
                                                                                                                                                                                                                                                                 let __v_192: G = __loaded[2];
                                                                                                                                                                                                                                                                 match __v_190.as_canonical_u64() {
                                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                                    let __ret: [G; OUT_23] = [__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[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                                    let __ret: [G; OUT_20] = [__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[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                                                                                                                                                                     return Ok(__ret);
                                                                                                                                                                                                                                                                   },
                                                                                                                                                                                                                                                                   _ => {
@@ -4232,22 +4129,22 @@ fn aiur_fn_23(
   })
 }
 
-const INPUT_SIZE_24: usize = 2;
-const IN_24: usize = 2;
-const OUT_24: usize = 1;
-fn aiur_fn_24(
-  inp: [G; IN_24],
+const INPUT_SIZE_21: usize = 2;
+const IN_21: usize = 2;
+const OUT_21: usize = 1;
+fn aiur_fn_21(
+  inp: [G; IN_21],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_24], ExecError> {
+) -> Result<[G; OUT_21], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_24] = [__v_0];
-        record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_21] = [__v_0];
+        record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -4256,25 +4153,25 @@ fn aiur_fn_24(
         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_24] = { let __args: [G; IN_24] = [__v_4, __v_6]; 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 __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_4, __v_6]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_24] = [__v_7];
-        record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_21] = [__v_7];
+        record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_25: usize = 6;
-const IN_25: usize = 6;
-const OUT_25: usize = 1;
-fn aiur_fn_25(
-  inp: [G; IN_25],
+const INPUT_SIZE_22: usize = 6;
+const IN_22: usize = 6;
+const OUT_22: usize = 1;
+fn aiur_fn_22(
+  inp: [G; IN_22],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_25], ExecError> {
+) -> Result<[G; OUT_22], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -4424,7 +4321,7 @@ fn aiur_fn_25(
                                             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_29] = { let __args: [G; IN_29] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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 __r_arr: [G; OUT_32] = { let __args: [G; IN_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, __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[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_125: G = __r_arr[0];
                                             let __v_126: G = __r_arr[1];
                                             let __v_127: G = __r_arr[2];
@@ -4458,62 +4355,62 @@ fn aiur_fn_25(
                                             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_25] = [__v_157];
-                                            record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_22] = [__v_157];
+                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __ret: [G; OUT_25] = [__v_5];
-                                            record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_22] = [__v_5];
+                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
                                       },
                                       _ => {
-                                        let __ret: [G; OUT_25] = [__v_5];
-                                        record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_22] = [__v_5];
+                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
                                   },
                                   _ => {
-                                    let __ret: [G; OUT_25] = [__v_5];
-                                    record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_22] = [__v_5];
+                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
-                                let __ret: [G; OUT_25] = [__v_5];
-                                record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_22] = [__v_5];
+                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
-                            let __ret: [G; OUT_25] = [__v_5];
-                            record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_22] = [__v_5];
+                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __ret: [G; OUT_25] = [__v_5];
-                        record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_22] = [__v_5];
+                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __ret: [G; OUT_25] = [__v_5];
-                    record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_22] = [__v_5];
+                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_25] = [__v_5];
-                record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_22] = [__v_5];
+                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -4554,8 +4451,8 @@ fn aiur_fn_25(
             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_25] = [__v_42];
-            record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_22] = [__v_42];
+            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -4580,9 +4477,9 @@ fn aiur_fn_25(
         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_24] = { let __args: [G; IN_24] = [__v_0, __v_25]; 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 __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_25]; 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_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_26]; 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 __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_26]; 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_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
         let __v_29: G = __r_arr[2];
@@ -4690,7 +4587,7 @@ fn aiur_fn_25(
         let __v_129: G = __loaded[5];
         let __v_130: G = __loaded[6];
         let __v_131: G = __loaded[7];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__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[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 __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__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[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_132: G = __r_arr[0];
         let __v_133: G = __r_arr[1];
         let __v_134: G = __r_arr[2];
@@ -4724,23 +4621,23 @@ fn aiur_fn_25(
         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_25] = [__v_164];
-        record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_22] = [__v_164];
+        record.function_queries[22].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],
+const INPUT_SIZE_23: usize = 6;
+const IN_23: usize = 6;
+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_26], ExecError> {
+) -> Result<[G; OUT_23], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -4751,7 +4648,7 @@ fn aiur_fn_26(
     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_23] = { let __args: [G; IN_23] = [__v_1]; 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 __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_1]; 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_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
     let __v_11: G = __r_arr[2];
@@ -4818,7 +4715,7 @@ fn aiur_fn_26(
     let __v_72: G = __r_arr[63];
     match __v_2.as_canonical_u64() {
       1023u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -4910,7 +4807,7 @@ fn aiur_fn_26(
         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_29] = { let __args: [G; IN_29] = [__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[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 __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__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[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_160: G = __r_arr[0];
         let __v_161: G = __r_arr[1];
         let __v_162: G = __r_arr[2];
@@ -4958,7 +4855,7 @@ fn aiur_fn_26(
         let __v_203: G = __loaded[5];
         let __v_204: G = __loaded[6];
         let __v_205: G = __loaded[7];
-        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[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_206: G = __r_arr[0];
         let __v_207: G = __r_arr[1];
         let __v_208: G = __r_arr[2];
@@ -4969,17 +4866,17 @@ fn aiur_fn_26(
         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_22] = { let __args: [G; IN_22] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; 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 __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
         let __v_216: G = __r_arr[0];
-        let __ret: [G; OUT_26] = [__v_216];
-        record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_23] = [__v_216];
+        record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
         let __v_73: G = __r_arr[0];
         let __v_74: G = (__v_73 * __v_7);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -5043,7 +4940,7 @@ fn aiur_fn_26(
         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_29] = { let __args: [G; IN_29] = [__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[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 __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__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[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_134: G = __r_arr[0];
         let __v_135: G = __r_arr[1];
         let __v_136: G = __r_arr[2];
@@ -5083,25 +4980,219 @@ fn aiur_fn_26(
         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_22] = { let __args: [G; IN_22] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; 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 __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
         let __v_173: G = __r_arr[0];
-        let __ret: [G; OUT_26] = [__v_173];
-        record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_23] = [__v_173];
+        record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_27: usize = 24;
-const IN_27: usize = 24;
-const OUT_27: usize = 16;
+const INPUT_SIZE_24: usize = 12;
+const IN_24: usize = 12;
+const OUT_24: usize = 4;
+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 __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __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 __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_4) } else { bytes2_add_value(__v_0, __v_4, record) };
+    let __v_12: G = __b2_add.0;
+    let __v_13: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_12, &__v_8) } else { bytes2_add_value(__v_12, __v_8, record) };
+    let __v_14: G = __b2_add.0;
+    let __v_15: G = __b2_add.1;
+    let __v_16: G = (__v_13 + __v_15);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) };
+    let __v_17: G = __b2_add.0;
+    let __v_18: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_17, &__v_9) } else { bytes2_add_value(__v_17, __v_9, record) };
+    let __v_19: G = __b2_add.0;
+    let __v_20: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_19, &__v_16) } else { bytes2_add_value(__v_19, __v_16, record) };
+    let __v_21: G = __b2_add.0;
+    let __v_22: G = __b2_add.1;
+    let __v_23: G = (__v_20 + __v_22);
+    let __v_24: G = (__v_18 + __v_23);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) };
+    let __v_25: G = __b2_add.0;
+    let __v_26: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_25, &__v_10) } else { bytes2_add_value(__v_25, __v_10, record) };
+    let __v_27: G = __b2_add.0;
+    let __v_28: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_27, &__v_24) } else { bytes2_add_value(__v_27, __v_24, record) };
+    let __v_29: G = __b2_add.0;
+    let __v_30: G = __b2_add.1;
+    let __v_31: G = (__v_28 + __v_30);
+    let __v_32: G = (__v_26 + __v_31);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_7) } else { bytes2_add_value(__v_3, __v_7, record) };
+    let __v_33: G = __b2_add.0;
+    let __v_34: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_33, &__v_11) } else { bytes2_add_value(__v_33, __v_11, record) };
+    let __v_35: G = __b2_add.0;
+    let __v_36: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_35, &__v_32) } else { bytes2_add_value(__v_35, __v_32, record) };
+    let __v_37: G = __b2_add.0;
+    let __v_38: G = __b2_add.1;
+    let __ret: [G; OUT_24] = [__v_14, __v_21, __v_29, __v_37];
+    record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_25: usize = 8;
+const IN_25: usize = 8;
+const OUT_25: usize = 4;
+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];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = if unconstrained { Bytes2::xor(&__v_0, &__v_4) } else { bytes2_xor_value(__v_0, __v_4, record) };
+    let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) };
+    let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) };
+    let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) };
+    let __ret: [G; OUT_25] = [__v_8, __v_9, __v_10, __v_11];
+    record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_26: usize = 4;
+const IN_26: usize = 4;
+const OUT_26: usize = 4;
+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 __ret: [G; OUT_26] = [__v_2, __v_3, __v_0, __v_1];
+    record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_27: usize = 4;
+const IN_27: usize = 4;
+const OUT_27: usize = 4;
 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 __ret: [G; OUT_27] = [__v_1, __v_2, __v_3, __v_0];
+    record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_28: usize = 4;
+const IN_28: usize = 4;
+const OUT_28: usize = 4;
+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 __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr(4, &__v_1, &__v_2) } else { bytes2_chain_rotr_value(4, __v_1, __v_2, record) };
+    let __v_4: G = __b2_out.0;
+    let __v_5: G = __b2_out.1;
+    let __v_6: G = __b2_out.2;
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr(4, &__v_3, &__v_0) } else { bytes2_chain_rotr_value(4, __v_3, __v_0, record) };
+    let __v_7: G = __b2_out.0;
+    let __v_8: G = __b2_out.1;
+    let __v_9: G = __b2_out.2;
+    let __v_10: G = (__v_5 + __v_9);
+    let __v_11: G = (__v_8 + __v_6);
+    let __ret: [G; OUT_28] = [__v_4, __v_10, __v_7, __v_11];
+    record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_29: usize = 4;
+const IN_29: usize = 4;
+const OUT_29: usize = 4;
+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 __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr(7, &__v_0, &__v_1) } else { bytes2_chain_rotr_value(7, __v_0, __v_1, record) };
+    let __v_4: G = __b2_out.0;
+    let __v_5: G = __b2_out.1;
+    let __v_6: G = __b2_out.2;
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr(7, &__v_2, &__v_3) } else { bytes2_chain_rotr_value(7, __v_2, __v_3, record) };
+    let __v_7: G = __b2_out.0;
+    let __v_8: G = __b2_out.1;
+    let __v_9: G = __b2_out.2;
+    let __v_10: G = (__v_5 + __v_9);
+    let __v_11: G = (__v_8 + __v_6);
+    let __ret: [G; OUT_29] = [__v_4, __v_10, __v_7, __v_11];
+    record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_30: usize = 24;
+const IN_30: usize = 24;
+const OUT_30: usize = 16;
+fn aiur_fn_30(
+  inp: [G; IN_30],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_30], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -5130,192 +5221,176 @@ fn aiur_fn_27(
     let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_4) } else { bytes2_add_value(__v_0, __v_4, record) };
     let __v_24: G = __b2_add.0;
     let __v_25: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) };
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_24, &__v_16) } else { bytes2_add_value(__v_24, __v_16, record) };
     let __v_26: G = __b2_add.0;
     let __v_27: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_26, &__v_25) } else { bytes2_add_value(__v_26, __v_25, record) };
-    let __v_28: G = __b2_add.0;
-    let __v_29: G = __b2_add.1;
-    let __v_30: G = (__v_27 + __v_29);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) };
+    let __v_28: G = (__v_25 + __v_27);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) };
+    let __v_29: G = __b2_add.0;
+    let __v_30: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_29, &__v_17) } else { bytes2_add_value(__v_29, __v_17, record) };
     let __v_31: G = __b2_add.0;
     let __v_32: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_31, &__v_30) } else { bytes2_add_value(__v_31, __v_30, record) };
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_31, &__v_28) } else { bytes2_add_value(__v_31, __v_28, record) };
     let __v_33: G = __b2_add.0;
     let __v_34: G = __b2_add.1;
     let __v_35: G = (__v_32 + __v_34);
+    let __v_36: G = (__v_30 + __v_35);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) };
+    let __v_37: G = __b2_add.0;
+    let __v_38: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_37, &__v_18) } else { bytes2_add_value(__v_37, __v_18, record) };
+    let __v_39: G = __b2_add.0;
+    let __v_40: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_39, &__v_36) } else { bytes2_add_value(__v_39, __v_36, record) };
+    let __v_41: G = __b2_add.0;
+    let __v_42: G = __b2_add.1;
+    let __v_43: G = (__v_40 + __v_42);
+    let __v_44: G = (__v_38 + __v_43);
     let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_7) } else { bytes2_add_value(__v_3, __v_7, record) };
-    let __v_36: G = __b2_add.0;
-    let __v_37: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_36, &__v_35) } else { bytes2_add_value(__v_36, __v_35, record) };
-    let __v_38: G = __b2_add.0;
-    let __v_39: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_24, &__v_16) } else { bytes2_add_value(__v_24, __v_16, record) };
-    let __v_40: G = __b2_add.0;
-    let __v_41: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_28, &__v_17) } else { bytes2_add_value(__v_28, __v_17, record) };
-    let __v_42: G = __b2_add.0;
-    let __v_43: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_42, &__v_41) } else { bytes2_add_value(__v_42, __v_41, record) };
-    let __v_44: G = __b2_add.0;
-    let __v_45: G = __b2_add.1;
-    let __v_46: G = (__v_43 + __v_45);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_33, &__v_18) } else { bytes2_add_value(__v_33, __v_18, record) };
+    let __v_45: G = __b2_add.0;
+    let __v_46: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_45, &__v_19) } else { bytes2_add_value(__v_45, __v_19, record) };
     let __v_47: G = __b2_add.0;
     let __v_48: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_47, &__v_46) } else { bytes2_add_value(__v_47, __v_46, record) };
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_47, &__v_44) } else { bytes2_add_value(__v_47, __v_44, record) };
     let __v_49: G = __b2_add.0;
     let __v_50: G = __b2_add.1;
-    let __v_51: G = (__v_48 + __v_50);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_38, &__v_19) } else { bytes2_add_value(__v_38, __v_19, record) };
-    let __v_52: G = __b2_add.0;
-    let __v_53: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_52, &__v_51) } else { bytes2_add_value(__v_52, __v_51, record) };
-    let __v_54: G = __b2_add.0;
-    let __v_55: G = __b2_add.1;
-    let __v_56: G = if unconstrained { Bytes2::xor(&__v_12, &__v_40) } else { bytes2_xor_value(__v_12, __v_40, record) };
-    let __v_57: G = if unconstrained { Bytes2::xor(&__v_13, &__v_44) } else { bytes2_xor_value(__v_13, __v_44, record) };
-    let __v_58: G = if unconstrained { Bytes2::xor(&__v_14, &__v_49) } else { bytes2_xor_value(__v_14, __v_49, record) };
-    let __v_59: G = if unconstrained { Bytes2::xor(&__v_15, &__v_54) } else { bytes2_xor_value(__v_15, __v_54, record) };
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_8, &__v_58) } else { bytes2_add_value(__v_8, __v_58, record) };
-    let __v_60: G = __b2_add.0;
-    let __v_61: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_9, &__v_59) } else { bytes2_add_value(__v_9, __v_59, record) };
+    let __v_51: G = if unconstrained { Bytes2::xor(&__v_12, &__v_26) } else { bytes2_xor_value(__v_12, __v_26, record) };
+    let __v_52: G = if unconstrained { Bytes2::xor(&__v_13, &__v_33) } else { bytes2_xor_value(__v_13, __v_33, record) };
+    let __v_53: G = if unconstrained { Bytes2::xor(&__v_14, &__v_41) } else { bytes2_xor_value(__v_14, __v_41, record) };
+    let __v_54: G = if unconstrained { Bytes2::xor(&__v_15, &__v_49) } else { bytes2_xor_value(__v_15, __v_49, record) };
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_8, &__v_53) } else { bytes2_add_value(__v_8, __v_53, record) };
+    let __v_55: G = __b2_add.0;
+    let __v_56: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_9, &__v_54) } else { bytes2_add_value(__v_9, __v_54, record) };
+    let __v_57: G = __b2_add.0;
+    let __v_58: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_57, &__v_56) } else { bytes2_add_value(__v_57, __v_56, record) };
+    let __v_59: G = __b2_add.0;
+    let __v_60: G = __b2_add.1;
+    let __v_61: G = (__v_58 + __v_60);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_10, &__v_51) } else { bytes2_add_value(__v_10, __v_51, record) };
     let __v_62: G = __b2_add.0;
     let __v_63: G = __b2_add.1;
     let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_62, &__v_61) } else { bytes2_add_value(__v_62, __v_61, record) };
     let __v_64: G = __b2_add.0;
     let __v_65: G = __b2_add.1;
     let __v_66: G = (__v_63 + __v_65);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_10, &__v_56) } else { bytes2_add_value(__v_10, __v_56, record) };
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_11, &__v_52) } else { bytes2_add_value(__v_11, __v_52, record) };
     let __v_67: G = __b2_add.0;
     let __v_68: G = __b2_add.1;
     let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_67, &__v_66) } else { bytes2_add_value(__v_67, __v_66, record) };
     let __v_69: G = __b2_add.0;
     let __v_70: G = __b2_add.1;
-    let __v_71: G = (__v_68 + __v_70);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_11, &__v_57) } else { bytes2_add_value(__v_11, __v_57, record) };
-    let __v_72: G = __b2_add.0;
-    let __v_73: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_72, &__v_71) } else { bytes2_add_value(__v_72, __v_71, record) };
-    let __v_74: G = __b2_add.0;
-    let __v_75: G = __b2_add.1;
-    let __v_76: G = if unconstrained { Bytes2::xor(&__v_4, &__v_60) } else { bytes2_xor_value(__v_4, __v_60, record) };
-    let __v_77: G = if unconstrained { Bytes2::xor(&__v_5, &__v_64) } else { bytes2_xor_value(__v_5, __v_64, record) };
-    let __v_78: G = if unconstrained { Bytes2::xor(&__v_6, &__v_69) } else { bytes2_xor_value(__v_6, __v_69, record) };
-    let __v_79: G = if unconstrained { Bytes2::xor(&__v_7, &__v_74) } else { bytes2_xor_value(__v_7, __v_74, record) };
-    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr4(&__v_77, &__v_78) } else { bytes2_chain_rotr4_value(__v_77, __v_78, record) };
-    let __v_80: G = __b2_out.0;
-    let __v_81: G = __b2_out.1;
-    let __v_82: G = __b2_out.2;
-    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr4(&__v_79, &__v_76) } else { bytes2_chain_rotr4_value(__v_79, __v_76, record) };
-    let __v_83: G = __b2_out.0;
-    let __v_84: G = __b2_out.1;
-    let __v_85: G = __b2_out.2;
-    let __v_86: G = (__v_81 + __v_85);
-    let __v_87: G = (__v_84 + __v_82);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_40, &__v_80) } else { bytes2_add_value(__v_40, __v_80, record) };
+    let __v_71: G = if unconstrained { Bytes2::xor(&__v_4, &__v_55) } else { bytes2_xor_value(__v_4, __v_55, record) };
+    let __v_72: G = if unconstrained { Bytes2::xor(&__v_5, &__v_59) } else { bytes2_xor_value(__v_5, __v_59, record) };
+    let __v_73: G = if unconstrained { Bytes2::xor(&__v_6, &__v_64) } else { bytes2_xor_value(__v_6, __v_64, record) };
+    let __v_74: G = if unconstrained { Bytes2::xor(&__v_7, &__v_69) } else { bytes2_xor_value(__v_7, __v_69, record) };
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr(4, &__v_72, &__v_73) } else { bytes2_chain_rotr_value(4, __v_72, __v_73, record) };
+    let __v_75: G = __b2_out.0;
+    let __v_76: G = __b2_out.1;
+    let __v_77: G = __b2_out.2;
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr(4, &__v_74, &__v_71) } else { bytes2_chain_rotr_value(4, __v_74, __v_71, record) };
+    let __v_78: G = __b2_out.0;
+    let __v_79: G = __b2_out.1;
+    let __v_80: G = __b2_out.2;
+    let __v_81: G = (__v_76 + __v_80);
+    let __v_82: G = (__v_79 + __v_77);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_26, &__v_75) } else { bytes2_add_value(__v_26, __v_75, record) };
+    let __v_83: G = __b2_add.0;
+    let __v_84: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_83, &__v_20) } else { bytes2_add_value(__v_83, __v_20, record) };
+    let __v_85: G = __b2_add.0;
+    let __v_86: G = __b2_add.1;
+    let __v_87: G = (__v_84 + __v_86);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_33, &__v_81) } else { bytes2_add_value(__v_33, __v_81, record) };
     let __v_88: G = __b2_add.0;
     let __v_89: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_44, &__v_86) } else { bytes2_add_value(__v_44, __v_86, record) };
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_88, &__v_21) } else { bytes2_add_value(__v_88, __v_21, record) };
     let __v_90: G = __b2_add.0;
     let __v_91: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_90, &__v_89) } else { bytes2_add_value(__v_90, __v_89, record) };
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_90, &__v_87) } else { bytes2_add_value(__v_90, __v_87, record) };
     let __v_92: G = __b2_add.0;
     let __v_93: G = __b2_add.1;
     let __v_94: G = (__v_91 + __v_93);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_49, &__v_83) } else { bytes2_add_value(__v_49, __v_83, record) };
-    let __v_95: G = __b2_add.0;
-    let __v_96: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_95, &__v_94) } else { bytes2_add_value(__v_95, __v_94, record) };
-    let __v_97: G = __b2_add.0;
-    let __v_98: G = __b2_add.1;
-    let __v_99: G = (__v_96 + __v_98);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_54, &__v_87) } else { bytes2_add_value(__v_54, __v_87, record) };
+    let __v_95: G = (__v_89 + __v_94);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_41, &__v_78) } else { bytes2_add_value(__v_41, __v_78, record) };
+    let __v_96: G = __b2_add.0;
+    let __v_97: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_96, &__v_22) } else { bytes2_add_value(__v_96, __v_22, record) };
+    let __v_98: G = __b2_add.0;
+    let __v_99: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_98, &__v_95) } else { bytes2_add_value(__v_98, __v_95, record) };
     let __v_100: G = __b2_add.0;
     let __v_101: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_100, &__v_99) } else { bytes2_add_value(__v_100, __v_99, record) };
-    let __v_102: G = __b2_add.0;
-    let __v_103: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_88, &__v_20) } else { bytes2_add_value(__v_88, __v_20, record) };
+    let __v_102: G = (__v_99 + __v_101);
+    let __v_103: G = (__v_97 + __v_102);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_49, &__v_82) } else { bytes2_add_value(__v_49, __v_82, record) };
     let __v_104: G = __b2_add.0;
     let __v_105: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_92, &__v_21) } else { bytes2_add_value(__v_92, __v_21, record) };
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_104, &__v_23) } else { bytes2_add_value(__v_104, __v_23, record) };
     let __v_106: G = __b2_add.0;
     let __v_107: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_106, &__v_105) } else { bytes2_add_value(__v_106, __v_105, record) };
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_106, &__v_103) } else { bytes2_add_value(__v_106, __v_103, record) };
     let __v_108: G = __b2_add.0;
     let __v_109: G = __b2_add.1;
-    let __v_110: G = (__v_107 + __v_109);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_97, &__v_22) } else { bytes2_add_value(__v_97, __v_22, record) };
-    let __v_111: G = __b2_add.0;
-    let __v_112: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_111, &__v_110) } else { bytes2_add_value(__v_111, __v_110, record) };
-    let __v_113: G = __b2_add.0;
-    let __v_114: G = __b2_add.1;
-    let __v_115: G = (__v_112 + __v_114);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_102, &__v_23) } else { bytes2_add_value(__v_102, __v_23, record) };
+    let __v_110: G = if unconstrained { Bytes2::xor(&__v_53, &__v_85) } else { bytes2_xor_value(__v_53, __v_85, record) };
+    let __v_111: G = if unconstrained { Bytes2::xor(&__v_54, &__v_92) } else { bytes2_xor_value(__v_54, __v_92, record) };
+    let __v_112: G = if unconstrained { Bytes2::xor(&__v_51, &__v_100) } else { bytes2_xor_value(__v_51, __v_100, record) };
+    let __v_113: G = if unconstrained { Bytes2::xor(&__v_52, &__v_108) } else { bytes2_xor_value(__v_52, __v_108, record) };
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_55, &__v_111) } else { bytes2_add_value(__v_55, __v_111, record) };
+    let __v_114: G = __b2_add.0;
+    let __v_115: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_59, &__v_112) } else { bytes2_add_value(__v_59, __v_112, record) };
     let __v_116: G = __b2_add.0;
     let __v_117: G = __b2_add.1;
     let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_116, &__v_115) } else { bytes2_add_value(__v_116, __v_115, record) };
     let __v_118: G = __b2_add.0;
     let __v_119: G = __b2_add.1;
-    let __v_120: G = if unconstrained { Bytes2::xor(&__v_58, &__v_104) } else { bytes2_xor_value(__v_58, __v_104, record) };
-    let __v_121: G = if unconstrained { Bytes2::xor(&__v_59, &__v_108) } else { bytes2_xor_value(__v_59, __v_108, record) };
-    let __v_122: G = if unconstrained { Bytes2::xor(&__v_56, &__v_113) } else { bytes2_xor_value(__v_56, __v_113, record) };
-    let __v_123: G = if unconstrained { Bytes2::xor(&__v_57, &__v_118) } else { bytes2_xor_value(__v_57, __v_118, record) };
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_60, &__v_121) } else { bytes2_add_value(__v_60, __v_121, record) };
-    let __v_124: G = __b2_add.0;
-    let __v_125: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_64, &__v_122) } else { bytes2_add_value(__v_64, __v_122, record) };
+    let __v_120: G = (__v_117 + __v_119);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_64, &__v_113) } else { bytes2_add_value(__v_64, __v_113, record) };
+    let __v_121: G = __b2_add.0;
+    let __v_122: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_121, &__v_120) } else { bytes2_add_value(__v_121, __v_120, record) };
+    let __v_123: G = __b2_add.0;
+    let __v_124: G = __b2_add.1;
+    let __v_125: G = (__v_122 + __v_124);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_69, &__v_110) } else { bytes2_add_value(__v_69, __v_110, record) };
     let __v_126: G = __b2_add.0;
     let __v_127: G = __b2_add.1;
     let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_126, &__v_125) } else { bytes2_add_value(__v_126, __v_125, record) };
     let __v_128: G = __b2_add.0;
     let __v_129: G = __b2_add.1;
-    let __v_130: G = (__v_127 + __v_129);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_69, &__v_123) } else { bytes2_add_value(__v_69, __v_123, record) };
-    let __v_131: G = __b2_add.0;
-    let __v_132: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_131, &__v_130) } else { bytes2_add_value(__v_131, __v_130, record) };
-    let __v_133: G = __b2_add.0;
-    let __v_134: G = __b2_add.1;
-    let __v_135: G = (__v_132 + __v_134);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_74, &__v_120) } else { bytes2_add_value(__v_74, __v_120, record) };
-    let __v_136: G = __b2_add.0;
-    let __v_137: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_136, &__v_135) } else { bytes2_add_value(__v_136, __v_135, record) };
-    let __v_138: G = __b2_add.0;
-    let __v_139: G = __b2_add.1;
-    let __v_140: G = if unconstrained { Bytes2::xor(&__v_80, &__v_124) } else { bytes2_xor_value(__v_80, __v_124, record) };
-    let __v_141: G = if unconstrained { Bytes2::xor(&__v_86, &__v_128) } else { bytes2_xor_value(__v_86, __v_128, record) };
-    let __v_142: G = if unconstrained { Bytes2::xor(&__v_83, &__v_133) } else { bytes2_xor_value(__v_83, __v_133, record) };
-    let __v_143: G = if unconstrained { Bytes2::xor(&__v_87, &__v_138) } else { bytes2_xor_value(__v_87, __v_138, record) };
-    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr7(&__v_140, &__v_141) } else { bytes2_chain_rotr7_value(__v_140, __v_141, record) };
-    let __v_144: G = __b2_out.0;
-    let __v_145: G = __b2_out.1;
-    let __v_146: G = __b2_out.2;
-    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr7(&__v_142, &__v_143) } else { bytes2_chain_rotr7_value(__v_142, __v_143, record) };
-    let __v_147: G = __b2_out.0;
-    let __v_148: G = __b2_out.1;
-    let __v_149: G = __b2_out.2;
-    let __v_150: G = (__v_145 + __v_149);
-    let __v_151: G = (__v_148 + __v_146);
-    let __ret: [G; OUT_27] = [__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[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_130: G = if unconstrained { Bytes2::xor(&__v_75, &__v_114) } else { bytes2_xor_value(__v_75, __v_114, record) };
+    let __v_131: G = if unconstrained { Bytes2::xor(&__v_81, &__v_118) } else { bytes2_xor_value(__v_81, __v_118, record) };
+    let __v_132: G = if unconstrained { Bytes2::xor(&__v_78, &__v_123) } else { bytes2_xor_value(__v_78, __v_123, record) };
+    let __v_133: G = if unconstrained { Bytes2::xor(&__v_82, &__v_128) } else { bytes2_xor_value(__v_82, __v_128, record) };
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr(7, &__v_130, &__v_131) } else { bytes2_chain_rotr_value(7, __v_130, __v_131, record) };
+    let __v_134: G = __b2_out.0;
+    let __v_135: G = __b2_out.1;
+    let __v_136: G = __b2_out.2;
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr(7, &__v_132, &__v_133) } else { bytes2_chain_rotr_value(7, __v_132, __v_133, record) };
+    let __v_137: G = __b2_out.0;
+    let __v_138: G = __b2_out.1;
+    let __v_139: G = __b2_out.2;
+    let __v_140: G = (__v_135 + __v_139);
+    let __v_141: G = (__v_138 + __v_136);
+    let __ret: [G; OUT_30] = [__v_85, __v_92, __v_100, __v_108, __v_134, __v_140, __v_137, __v_141, __v_114, __v_118, __v_123, __v_128, __v_111, __v_112, __v_113, __v_110];
+    record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_28: usize = 128;
-const IN_28: usize = 128;
-const OUT_28: usize = 128;
-fn aiur_fn_28(
-  inp: [G; IN_28],
+const INPUT_SIZE_31: usize = 129;
+const IN_31: usize = 129;
+const OUT_31: usize = 128;
+fn aiur_fn_31(
+  inp: [G; IN_31],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_28], ExecError> {
+) -> Result<[G; OUT_31], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -5445,157 +5520,298 @@ fn aiur_fn_28(
     let __v_125: G = inp[125];
     let __v_126: G = inp[126];
     let __v_127: G = inp[127];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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[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_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_27] = { let __args: [G; IN_27] = [__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[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_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_27] = { let __args: [G; IN_27] = [__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[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_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_27] = { let __args: [G; IN_27] = [__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[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_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_27] = { let __args: [G; IN_27] = [__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[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_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_27] = { let __args: [G; IN_27] = [__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[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_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_27] = { let __args: [G; IN_27] = [__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[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_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_27] = { let __args: [G; IN_27] = [__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[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_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_28] = [__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[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_128: G = inp[128];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__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[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_129: G = __r_arr[0];
+    let __v_130: G = __r_arr[1];
+    let __v_131: G = __r_arr[2];
+    let __v_132: G = __r_arr[3];
+    let __v_133: G = __r_arr[4];
+    let __v_134: G = __r_arr[5];
+    let __v_135: G = __r_arr[6];
+    let __v_136: G = __r_arr[7];
+    let __v_137: G = __r_arr[8];
+    let __v_138: G = __r_arr[9];
+    let __v_139: G = __r_arr[10];
+    let __v_140: G = __r_arr[11];
+    let __v_141: G = __r_arr[12];
+    let __v_142: G = __r_arr[13];
+    let __v_143: G = __r_arr[14];
+    let __v_144: G = __r_arr[15];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__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[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_145: G = __r_arr[0];
+    let __v_146: G = __r_arr[1];
+    let __v_147: G = __r_arr[2];
+    let __v_148: G = __r_arr[3];
+    let __v_149: G = __r_arr[4];
+    let __v_150: G = __r_arr[5];
+    let __v_151: G = __r_arr[6];
+    let __v_152: G = __r_arr[7];
+    let __v_153: G = __r_arr[8];
+    let __v_154: G = __r_arr[9];
+    let __v_155: G = __r_arr[10];
+    let __v_156: G = __r_arr[11];
+    let __v_157: G = __r_arr[12];
+    let __v_158: G = __r_arr[13];
+    let __v_159: G = __r_arr[14];
+    let __v_160: G = __r_arr[15];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__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[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_161: G = __r_arr[0];
+    let __v_162: G = __r_arr[1];
+    let __v_163: G = __r_arr[2];
+    let __v_164: G = __r_arr[3];
+    let __v_165: G = __r_arr[4];
+    let __v_166: G = __r_arr[5];
+    let __v_167: G = __r_arr[6];
+    let __v_168: G = __r_arr[7];
+    let __v_169: G = __r_arr[8];
+    let __v_170: G = __r_arr[9];
+    let __v_171: G = __r_arr[10];
+    let __v_172: G = __r_arr[11];
+    let __v_173: G = __r_arr[12];
+    let __v_174: G = __r_arr[13];
+    let __v_175: G = __r_arr[14];
+    let __v_176: G = __r_arr[15];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__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[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_177: G = __r_arr[0];
+    let __v_178: G = __r_arr[1];
+    let __v_179: G = __r_arr[2];
+    let __v_180: G = __r_arr[3];
+    let __v_181: G = __r_arr[4];
+    let __v_182: G = __r_arr[5];
+    let __v_183: G = __r_arr[6];
+    let __v_184: G = __r_arr[7];
+    let __v_185: G = __r_arr[8];
+    let __v_186: G = __r_arr[9];
+    let __v_187: G = __r_arr[10];
+    let __v_188: G = __r_arr[11];
+    let __v_189: G = __r_arr[12];
+    let __v_190: G = __r_arr[13];
+    let __v_191: G = __r_arr[14];
+    let __v_192: G = __r_arr[15];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_129, __v_130, __v_131, __v_132, __v_149, __v_150, __v_151, __v_152, __v_169, __v_170, __v_171, __v_172, __v_189, __v_190, __v_191, __v_192, __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[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_193: G = __r_arr[0];
+    let __v_194: G = __r_arr[1];
+    let __v_195: G = __r_arr[2];
+    let __v_196: G = __r_arr[3];
+    let __v_197: G = __r_arr[4];
+    let __v_198: G = __r_arr[5];
+    let __v_199: G = __r_arr[6];
+    let __v_200: G = __r_arr[7];
+    let __v_201: G = __r_arr[8];
+    let __v_202: G = __r_arr[9];
+    let __v_203: G = __r_arr[10];
+    let __v_204: G = __r_arr[11];
+    let __v_205: G = __r_arr[12];
+    let __v_206: G = __r_arr[13];
+    let __v_207: G = __r_arr[14];
+    let __v_208: G = __r_arr[15];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_145, __v_146, __v_147, __v_148, __v_165, __v_166, __v_167, __v_168, __v_185, __v_186, __v_187, __v_188, __v_141, __v_142, __v_143, __v_144, __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[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_209: G = __r_arr[0];
+    let __v_210: G = __r_arr[1];
+    let __v_211: G = __r_arr[2];
+    let __v_212: G = __r_arr[3];
+    let __v_213: G = __r_arr[4];
+    let __v_214: G = __r_arr[5];
+    let __v_215: G = __r_arr[6];
+    let __v_216: G = __r_arr[7];
+    let __v_217: G = __r_arr[8];
+    let __v_218: G = __r_arr[9];
+    let __v_219: G = __r_arr[10];
+    let __v_220: G = __r_arr[11];
+    let __v_221: G = __r_arr[12];
+    let __v_222: G = __r_arr[13];
+    let __v_223: G = __r_arr[14];
+    let __v_224: G = __r_arr[15];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_161, __v_162, __v_163, __v_164, __v_181, __v_182, __v_183, __v_184, __v_137, __v_138, __v_139, __v_140, __v_157, __v_158, __v_159, __v_160, __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[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_225: G = __r_arr[0];
+    let __v_226: G = __r_arr[1];
+    let __v_227: G = __r_arr[2];
+    let __v_228: G = __r_arr[3];
+    let __v_229: G = __r_arr[4];
+    let __v_230: G = __r_arr[5];
+    let __v_231: G = __r_arr[6];
+    let __v_232: G = __r_arr[7];
+    let __v_233: G = __r_arr[8];
+    let __v_234: G = __r_arr[9];
+    let __v_235: G = __r_arr[10];
+    let __v_236: G = __r_arr[11];
+    let __v_237: G = __r_arr[12];
+    let __v_238: G = __r_arr[13];
+    let __v_239: G = __r_arr[14];
+    let __v_240: G = __r_arr[15];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_177, __v_178, __v_179, __v_180, __v_133, __v_134, __v_135, __v_136, __v_153, __v_154, __v_155, __v_156, __v_173, __v_174, __v_175, __v_176, __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[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_241: G = __r_arr[0];
+    let __v_242: G = __r_arr[1];
+    let __v_243: G = __r_arr[2];
+    let __v_244: G = __r_arr[3];
+    let __v_245: G = __r_arr[4];
+    let __v_246: G = __r_arr[5];
+    let __v_247: G = __r_arr[6];
+    let __v_248: G = __r_arr[7];
+    let __v_249: G = __r_arr[8];
+    let __v_250: G = __r_arr[9];
+    let __v_251: G = __r_arr[10];
+    let __v_252: G = __r_arr[11];
+    let __v_253: G = __r_arr[12];
+    let __v_254: G = __r_arr[13];
+    let __v_255: G = __r_arr[14];
+    let __v_256: G = __r_arr[15];
+    match __v_128.as_canonical_u64() {
+      6u64 => {
+        let __ret: [G; OUT_31] = [__v_193, __v_194, __v_195, __v_196, __v_209, __v_210, __v_211, __v_212, __v_225, __v_226, __v_227, __v_228, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_197, __v_198, __v_199, __v_200, __v_213, __v_214, __v_215, __v_216, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_249, __v_250, __v_251, __v_252, __v_201, __v_202, __v_203, __v_204, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_237, __v_238, __v_239, __v_240, __v_253, __v_254, __v_255, __v_256, __v_205, __v_206, __v_207, __v_208, __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[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_257: G = G::from_u64(1);
+        let __v_258: G = (__v_128 + __v_257);
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_193, __v_194, __v_195, __v_196, __v_209, __v_210, __v_211, __v_212, __v_225, __v_226, __v_227, __v_228, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_197, __v_198, __v_199, __v_200, __v_213, __v_214, __v_215, __v_216, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_249, __v_250, __v_251, __v_252, __v_201, __v_202, __v_203, __v_204, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_237, __v_238, __v_239, __v_240, __v_253, __v_254, __v_255, __v_256, __v_205, __v_206, __v_207, __v_208, __v_72, __v_73, __v_74, __v_75, __v_88, __v_89, __v_90, __v_91, __v_76, __v_77, __v_78, __v_79, __v_104, __v_105, __v_106, __v_107, __v_92, __v_93, __v_94, __v_95, __v_64, __v_65, __v_66, __v_67, __v_80, __v_81, __v_82, __v_83, __v_116, __v_117, __v_118, __v_119, __v_68, __v_69, __v_70, __v_71, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_84, __v_85, __v_86, __v_87, __v_100, __v_101, __v_102, __v_103, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_96, __v_97, __v_98, __v_99, __v_258]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __v_259: G = __r_arr[0];
+        let __v_260: G = __r_arr[1];
+        let __v_261: G = __r_arr[2];
+        let __v_262: G = __r_arr[3];
+        let __v_263: G = __r_arr[4];
+        let __v_264: G = __r_arr[5];
+        let __v_265: G = __r_arr[6];
+        let __v_266: G = __r_arr[7];
+        let __v_267: G = __r_arr[8];
+        let __v_268: G = __r_arr[9];
+        let __v_269: G = __r_arr[10];
+        let __v_270: G = __r_arr[11];
+        let __v_271: G = __r_arr[12];
+        let __v_272: G = __r_arr[13];
+        let __v_273: G = __r_arr[14];
+        let __v_274: G = __r_arr[15];
+        let __v_275: G = __r_arr[16];
+        let __v_276: G = __r_arr[17];
+        let __v_277: G = __r_arr[18];
+        let __v_278: G = __r_arr[19];
+        let __v_279: G = __r_arr[20];
+        let __v_280: G = __r_arr[21];
+        let __v_281: G = __r_arr[22];
+        let __v_282: G = __r_arr[23];
+        let __v_283: G = __r_arr[24];
+        let __v_284: G = __r_arr[25];
+        let __v_285: G = __r_arr[26];
+        let __v_286: G = __r_arr[27];
+        let __v_287: G = __r_arr[28];
+        let __v_288: G = __r_arr[29];
+        let __v_289: G = __r_arr[30];
+        let __v_290: G = __r_arr[31];
+        let __v_291: G = __r_arr[32];
+        let __v_292: G = __r_arr[33];
+        let __v_293: G = __r_arr[34];
+        let __v_294: G = __r_arr[35];
+        let __v_295: G = __r_arr[36];
+        let __v_296: G = __r_arr[37];
+        let __v_297: G = __r_arr[38];
+        let __v_298: G = __r_arr[39];
+        let __v_299: G = __r_arr[40];
+        let __v_300: G = __r_arr[41];
+        let __v_301: G = __r_arr[42];
+        let __v_302: G = __r_arr[43];
+        let __v_303: G = __r_arr[44];
+        let __v_304: G = __r_arr[45];
+        let __v_305: G = __r_arr[46];
+        let __v_306: G = __r_arr[47];
+        let __v_307: G = __r_arr[48];
+        let __v_308: G = __r_arr[49];
+        let __v_309: G = __r_arr[50];
+        let __v_310: G = __r_arr[51];
+        let __v_311: G = __r_arr[52];
+        let __v_312: G = __r_arr[53];
+        let __v_313: G = __r_arr[54];
+        let __v_314: G = __r_arr[55];
+        let __v_315: G = __r_arr[56];
+        let __v_316: G = __r_arr[57];
+        let __v_317: G = __r_arr[58];
+        let __v_318: G = __r_arr[59];
+        let __v_319: G = __r_arr[60];
+        let __v_320: G = __r_arr[61];
+        let __v_321: G = __r_arr[62];
+        let __v_322: G = __r_arr[63];
+        let __v_323: G = __r_arr[64];
+        let __v_324: G = __r_arr[65];
+        let __v_325: G = __r_arr[66];
+        let __v_326: G = __r_arr[67];
+        let __v_327: G = __r_arr[68];
+        let __v_328: G = __r_arr[69];
+        let __v_329: G = __r_arr[70];
+        let __v_330: G = __r_arr[71];
+        let __v_331: G = __r_arr[72];
+        let __v_332: G = __r_arr[73];
+        let __v_333: G = __r_arr[74];
+        let __v_334: G = __r_arr[75];
+        let __v_335: G = __r_arr[76];
+        let __v_336: G = __r_arr[77];
+        let __v_337: G = __r_arr[78];
+        let __v_338: G = __r_arr[79];
+        let __v_339: G = __r_arr[80];
+        let __v_340: G = __r_arr[81];
+        let __v_341: G = __r_arr[82];
+        let __v_342: G = __r_arr[83];
+        let __v_343: G = __r_arr[84];
+        let __v_344: G = __r_arr[85];
+        let __v_345: G = __r_arr[86];
+        let __v_346: G = __r_arr[87];
+        let __v_347: G = __r_arr[88];
+        let __v_348: G = __r_arr[89];
+        let __v_349: G = __r_arr[90];
+        let __v_350: G = __r_arr[91];
+        let __v_351: G = __r_arr[92];
+        let __v_352: G = __r_arr[93];
+        let __v_353: G = __r_arr[94];
+        let __v_354: G = __r_arr[95];
+        let __v_355: G = __r_arr[96];
+        let __v_356: G = __r_arr[97];
+        let __v_357: G = __r_arr[98];
+        let __v_358: G = __r_arr[99];
+        let __v_359: G = __r_arr[100];
+        let __v_360: G = __r_arr[101];
+        let __v_361: G = __r_arr[102];
+        let __v_362: G = __r_arr[103];
+        let __v_363: G = __r_arr[104];
+        let __v_364: G = __r_arr[105];
+        let __v_365: G = __r_arr[106];
+        let __v_366: G = __r_arr[107];
+        let __v_367: G = __r_arr[108];
+        let __v_368: G = __r_arr[109];
+        let __v_369: G = __r_arr[110];
+        let __v_370: G = __r_arr[111];
+        let __v_371: G = __r_arr[112];
+        let __v_372: G = __r_arr[113];
+        let __v_373: G = __r_arr[114];
+        let __v_374: G = __r_arr[115];
+        let __v_375: G = __r_arr[116];
+        let __v_376: G = __r_arr[117];
+        let __v_377: G = __r_arr[118];
+        let __v_378: G = __r_arr[119];
+        let __v_379: G = __r_arr[120];
+        let __v_380: G = __r_arr[121];
+        let __v_381: G = __r_arr[122];
+        let __v_382: G = __r_arr[123];
+        let __v_383: G = __r_arr[124];
+        let __v_384: G = __r_arr[125];
+        let __v_385: G = __r_arr[126];
+        let __v_386: G = __r_arr[127];
+        let __ret: [G; OUT_31] = [__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_320, __v_321, __v_322, __v_323, __v_324, __v_325, __v_326, __v_327, __v_328, __v_329, __v_330, __v_331, __v_332, __v_333, __v_334, __v_335, __v_336, __v_337, __v_338, __v_339, __v_340, __v_341, __v_342, __v_343, __v_344, __v_345, __v_346, __v_347, __v_348, __v_349, __v_350, __v_351, __v_352, __v_353, __v_354, __v_355, __v_356, __v_357, __v_358, __v_359, __v_360, __v_361, __v_362, __v_363, __v_364, __v_365, __v_366, __v_367, __v_368, __v_369, __v_370, __v_371, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_378, __v_379, __v_380, __v_381, __v_382, __v_383, __v_384, __v_385, __v_386];
+        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_29: usize = 106;
-const IN_29: usize = 106;
-const OUT_29: usize = 32;
-fn aiur_fn_29(
-  inp: [G; IN_29],
+const INPUT_SIZE_32: usize = 106;
+const IN_32: usize = 106;
+const OUT_32: usize = 32;
+fn aiur_fn_32(
+  inp: [G; IN_32],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_29], ExecError> {
+) -> Result<[G; OUT_32], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -5725,962 +5941,189 @@ fn aiur_fn_29(
     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_28] = { let __args: [G; IN_28] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
-    let __v_128: G = __r_arr[0];
-    let __v_129: G = __r_arr[1];
-    let __v_130: G = __r_arr[2];
-    let __v_131: G = __r_arr[3];
-    let __v_132: G = __r_arr[4];
-    let __v_133: G = __r_arr[5];
-    let __v_134: G = __r_arr[6];
-    let __v_135: G = __r_arr[7];
-    let __v_136: G = __r_arr[8];
-    let __v_137: G = __r_arr[9];
-    let __v_138: G = __r_arr[10];
-    let __v_139: G = __r_arr[11];
-    let __v_140: G = __r_arr[12];
-    let __v_141: G = __r_arr[13];
-    let __v_142: G = __r_arr[14];
-    let __v_143: G = __r_arr[15];
-    let __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_28] = { let __args: [G; IN_28] = [__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[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_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_28] = { let __args: [G; IN_28] = [__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[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_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_28] = { let __args: [G; IN_28] = [__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[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_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_28] = { let __args: [G; IN_28] = [__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[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_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_28] = { let __args: [G; IN_28] = [__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[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_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_28] = { let __args: [G; IN_28] = [__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[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_896: G = __r_arr[0];
-    let __v_897: G = __r_arr[1];
-    let __v_898: G = __r_arr[2];
-    let __v_899: G = __r_arr[3];
-    let __v_900: G = __r_arr[4];
-    let __v_901: G = __r_arr[5];
-    let __v_902: G = __r_arr[6];
-    let __v_903: G = __r_arr[7];
-    let __v_904: G = __r_arr[8];
-    let __v_905: G = __r_arr[9];
-    let __v_906: G = __r_arr[10];
-    let __v_907: G = __r_arr[11];
-    let __v_908: G = __r_arr[12];
-    let __v_909: G = __r_arr[13];
-    let __v_910: G = __r_arr[14];
-    let __v_911: G = __r_arr[15];
-    let __v_912: G = __r_arr[16];
-    let __v_913: G = __r_arr[17];
-    let __v_914: G = __r_arr[18];
-    let __v_915: G = __r_arr[19];
-    let __v_916: G = __r_arr[20];
-    let __v_917: G = __r_arr[21];
-    let __v_918: G = __r_arr[22];
-    let __v_919: G = __r_arr[23];
-    let __v_920: G = __r_arr[24];
-    let __v_921: G = __r_arr[25];
-    let __v_922: G = __r_arr[26];
-    let __v_923: G = __r_arr[27];
-    let __v_924: G = __r_arr[28];
-    let __v_925: G = __r_arr[29];
-    let __v_926: G = __r_arr[30];
-    let __v_927: G = __r_arr[31];
-    let __v_928: G = __r_arr[32];
-    let __v_929: G = __r_arr[33];
-    let __v_930: G = __r_arr[34];
-    let __v_931: G = __r_arr[35];
-    let __v_932: G = __r_arr[36];
-    let __v_933: G = __r_arr[37];
-    let __v_934: G = __r_arr[38];
-    let __v_935: G = __r_arr[39];
-    let __v_936: G = __r_arr[40];
-    let __v_937: G = __r_arr[41];
-    let __v_938: G = __r_arr[42];
-    let __v_939: G = __r_arr[43];
-    let __v_940: G = __r_arr[44];
-    let __v_941: G = __r_arr[45];
-    let __v_942: G = __r_arr[46];
-    let __v_943: G = __r_arr[47];
-    let __v_944: G = __r_arr[48];
-    let __v_945: G = __r_arr[49];
-    let __v_946: G = __r_arr[50];
-    let __v_947: G = __r_arr[51];
-    let __v_948: G = __r_arr[52];
-    let __v_949: G = __r_arr[53];
-    let __v_950: G = __r_arr[54];
-    let __v_951: G = __r_arr[55];
-    let __v_952: G = __r_arr[56];
-    let __v_953: G = __r_arr[57];
-    let __v_954: G = __r_arr[58];
-    let __v_955: G = __r_arr[59];
-    let __v_956: G = __r_arr[60];
-    let __v_957: G = __r_arr[61];
-    let __v_958: G = __r_arr[62];
-    let __v_959: G = __r_arr[63];
-    let __v_960: G = __r_arr[64];
-    let __v_961: G = __r_arr[65];
-    let __v_962: G = __r_arr[66];
-    let __v_963: G = __r_arr[67];
-    let __v_964: G = __r_arr[68];
-    let __v_965: G = __r_arr[69];
-    let __v_966: G = __r_arr[70];
-    let __v_967: G = __r_arr[71];
-    let __v_968: G = __r_arr[72];
-    let __v_969: G = __r_arr[73];
-    let __v_970: G = __r_arr[74];
-    let __v_971: G = __r_arr[75];
-    let __v_972: G = __r_arr[76];
-    let __v_973: G = __r_arr[77];
-    let __v_974: G = __r_arr[78];
-    let __v_975: G = __r_arr[79];
-    let __v_976: G = __r_arr[80];
-    let __v_977: G = __r_arr[81];
-    let __v_978: G = __r_arr[82];
-    let __v_979: G = __r_arr[83];
-    let __v_980: G = __r_arr[84];
-    let __v_981: G = __r_arr[85];
-    let __v_982: G = __r_arr[86];
-    let __v_983: G = __r_arr[87];
-    let __v_984: G = __r_arr[88];
-    let __v_985: G = __r_arr[89];
-    let __v_986: G = __r_arr[90];
-    let __v_987: G = __r_arr[91];
-    let __v_988: G = __r_arr[92];
-    let __v_989: G = __r_arr[93];
-    let __v_990: G = __r_arr[94];
-    let __v_991: G = __r_arr[95];
-    let __v_992: G = __r_arr[96];
-    let __v_993: G = __r_arr[97];
-    let __v_994: G = __r_arr[98];
-    let __v_995: G = __r_arr[99];
-    let __v_996: G = __r_arr[100];
-    let __v_997: G = __r_arr[101];
-    let __v_998: G = __r_arr[102];
-    let __v_999: G = __r_arr[103];
-    let __v_1000: G = __r_arr[104];
-    let __v_1001: G = __r_arr[105];
-    let __v_1002: G = __r_arr[106];
-    let __v_1003: G = __r_arr[107];
-    let __v_1004: G = __r_arr[108];
-    let __v_1005: G = __r_arr[109];
-    let __v_1006: G = __r_arr[110];
-    let __v_1007: G = __r_arr[111];
-    let __v_1008: G = __r_arr[112];
-    let __v_1009: G = __r_arr[113];
-    let __v_1010: G = __r_arr[114];
-    let __v_1011: G = __r_arr[115];
-    let __v_1012: G = __r_arr[116];
-    let __v_1013: G = __r_arr[117];
-    let __v_1014: G = __r_arr[118];
-    let __v_1015: G = __r_arr[119];
-    let __v_1016: G = __r_arr[120];
-    let __v_1017: G = __r_arr[121];
-    let __v_1018: G = __r_arr[122];
-    let __v_1019: G = __r_arr[123];
-    let __v_1020: G = __r_arr[124];
-    let __v_1021: G = __r_arr[125];
-    let __v_1022: G = __r_arr[126];
-    let __v_1023: G = __r_arr[127];
-    let __v_1024: G = if unconstrained { Bytes2::xor(&__v_896, &__v_928) } else { bytes2_xor_value(__v_896, __v_928, record) };
-    let __v_1025: G = if unconstrained { Bytes2::xor(&__v_897, &__v_929) } else { bytes2_xor_value(__v_897, __v_929, record) };
-    let __v_1026: G = if unconstrained { Bytes2::xor(&__v_898, &__v_930) } else { bytes2_xor_value(__v_898, __v_930, record) };
-    let __v_1027: G = if unconstrained { Bytes2::xor(&__v_899, &__v_931) } else { bytes2_xor_value(__v_899, __v_931, record) };
-    let __v_1028: G = if unconstrained { Bytes2::xor(&__v_900, &__v_932) } else { bytes2_xor_value(__v_900, __v_932, record) };
-    let __v_1029: G = if unconstrained { Bytes2::xor(&__v_901, &__v_933) } else { bytes2_xor_value(__v_901, __v_933, record) };
-    let __v_1030: G = if unconstrained { Bytes2::xor(&__v_902, &__v_934) } else { bytes2_xor_value(__v_902, __v_934, record) };
-    let __v_1031: G = if unconstrained { Bytes2::xor(&__v_903, &__v_935) } else { bytes2_xor_value(__v_903, __v_935, record) };
-    let __v_1032: G = if unconstrained { Bytes2::xor(&__v_904, &__v_936) } else { bytes2_xor_value(__v_904, __v_936, record) };
-    let __v_1033: G = if unconstrained { Bytes2::xor(&__v_905, &__v_937) } else { bytes2_xor_value(__v_905, __v_937, record) };
-    let __v_1034: G = if unconstrained { Bytes2::xor(&__v_906, &__v_938) } else { bytes2_xor_value(__v_906, __v_938, record) };
-    let __v_1035: G = if unconstrained { Bytes2::xor(&__v_907, &__v_939) } else { bytes2_xor_value(__v_907, __v_939, record) };
-    let __v_1036: G = if unconstrained { Bytes2::xor(&__v_908, &__v_940) } else { bytes2_xor_value(__v_908, __v_940, record) };
-    let __v_1037: G = if unconstrained { Bytes2::xor(&__v_909, &__v_941) } else { bytes2_xor_value(__v_909, __v_941, record) };
-    let __v_1038: G = if unconstrained { Bytes2::xor(&__v_910, &__v_942) } else { bytes2_xor_value(__v_910, __v_942, record) };
-    let __v_1039: G = if unconstrained { Bytes2::xor(&__v_911, &__v_943) } else { bytes2_xor_value(__v_911, __v_943, record) };
-    let __v_1040: G = if unconstrained { Bytes2::xor(&__v_912, &__v_944) } else { bytes2_xor_value(__v_912, __v_944, record) };
-    let __v_1041: G = if unconstrained { Bytes2::xor(&__v_913, &__v_945) } else { bytes2_xor_value(__v_913, __v_945, record) };
-    let __v_1042: G = if unconstrained { Bytes2::xor(&__v_914, &__v_946) } else { bytes2_xor_value(__v_914, __v_946, record) };
-    let __v_1043: G = if unconstrained { Bytes2::xor(&__v_915, &__v_947) } else { bytes2_xor_value(__v_915, __v_947, record) };
-    let __v_1044: G = if unconstrained { Bytes2::xor(&__v_916, &__v_948) } else { bytes2_xor_value(__v_916, __v_948, record) };
-    let __v_1045: G = if unconstrained { Bytes2::xor(&__v_917, &__v_949) } else { bytes2_xor_value(__v_917, __v_949, record) };
-    let __v_1046: G = if unconstrained { Bytes2::xor(&__v_918, &__v_950) } else { bytes2_xor_value(__v_918, __v_950, record) };
-    let __v_1047: G = if unconstrained { Bytes2::xor(&__v_919, &__v_951) } else { bytes2_xor_value(__v_919, __v_951, record) };
-    let __v_1048: G = if unconstrained { Bytes2::xor(&__v_920, &__v_952) } else { bytes2_xor_value(__v_920, __v_952, record) };
-    let __v_1049: G = if unconstrained { Bytes2::xor(&__v_921, &__v_953) } else { bytes2_xor_value(__v_921, __v_953, record) };
-    let __v_1050: G = if unconstrained { Bytes2::xor(&__v_922, &__v_954) } else { bytes2_xor_value(__v_922, __v_954, record) };
-    let __v_1051: G = if unconstrained { Bytes2::xor(&__v_923, &__v_955) } else { bytes2_xor_value(__v_923, __v_955, record) };
-    let __v_1052: G = if unconstrained { Bytes2::xor(&__v_924, &__v_956) } else { bytes2_xor_value(__v_924, __v_956, record) };
-    let __v_1053: G = if unconstrained { Bytes2::xor(&__v_925, &__v_957) } else { bytes2_xor_value(__v_925, __v_957, record) };
-    let __v_1054: G = if unconstrained { Bytes2::xor(&__v_926, &__v_958) } else { bytes2_xor_value(__v_926, __v_958, record) };
-    let __v_1055: G = if unconstrained { Bytes2::xor(&__v_927, &__v_959) } else { bytes2_xor_value(__v_927, __v_959, record) };
-    let __ret: [G; OUT_29] = [__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[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_128: G = G::from_u64(0);
+    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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, __v_128]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+    let __v_129: G = __r_arr[0];
+    let __v_130: G = __r_arr[1];
+    let __v_131: G = __r_arr[2];
+    let __v_132: G = __r_arr[3];
+    let __v_133: G = __r_arr[4];
+    let __v_134: G = __r_arr[5];
+    let __v_135: G = __r_arr[6];
+    let __v_136: G = __r_arr[7];
+    let __v_137: G = __r_arr[8];
+    let __v_138: G = __r_arr[9];
+    let __v_139: G = __r_arr[10];
+    let __v_140: G = __r_arr[11];
+    let __v_141: G = __r_arr[12];
+    let __v_142: G = __r_arr[13];
+    let __v_143: G = __r_arr[14];
+    let __v_144: G = __r_arr[15];
+    let __v_145: G = __r_arr[16];
+    let __v_146: G = __r_arr[17];
+    let __v_147: G = __r_arr[18];
+    let __v_148: G = __r_arr[19];
+    let __v_149: G = __r_arr[20];
+    let __v_150: G = __r_arr[21];
+    let __v_151: G = __r_arr[22];
+    let __v_152: G = __r_arr[23];
+    let __v_153: G = __r_arr[24];
+    let __v_154: G = __r_arr[25];
+    let __v_155: G = __r_arr[26];
+    let __v_156: G = __r_arr[27];
+    let __v_157: G = __r_arr[28];
+    let __v_158: G = __r_arr[29];
+    let __v_159: G = __r_arr[30];
+    let __v_160: G = __r_arr[31];
+    let __v_161: G = __r_arr[32];
+    let __v_162: G = __r_arr[33];
+    let __v_163: G = __r_arr[34];
+    let __v_164: G = __r_arr[35];
+    let __v_165: G = __r_arr[36];
+    let __v_166: G = __r_arr[37];
+    let __v_167: G = __r_arr[38];
+    let __v_168: G = __r_arr[39];
+    let __v_169: G = __r_arr[40];
+    let __v_170: G = __r_arr[41];
+    let __v_171: G = __r_arr[42];
+    let __v_172: G = __r_arr[43];
+    let __v_173: G = __r_arr[44];
+    let __v_174: G = __r_arr[45];
+    let __v_175: G = __r_arr[46];
+    let __v_176: G = __r_arr[47];
+    let __v_177: G = __r_arr[48];
+    let __v_178: G = __r_arr[49];
+    let __v_179: G = __r_arr[50];
+    let __v_180: G = __r_arr[51];
+    let __v_181: G = __r_arr[52];
+    let __v_182: G = __r_arr[53];
+    let __v_183: G = __r_arr[54];
+    let __v_184: G = __r_arr[55];
+    let __v_185: G = __r_arr[56];
+    let __v_186: G = __r_arr[57];
+    let __v_187: G = __r_arr[58];
+    let __v_188: G = __r_arr[59];
+    let __v_189: G = __r_arr[60];
+    let __v_190: G = __r_arr[61];
+    let __v_191: G = __r_arr[62];
+    let __v_192: G = __r_arr[63];
+    let __v_193: G = __r_arr[64];
+    let __v_194: G = __r_arr[65];
+    let __v_195: G = __r_arr[66];
+    let __v_196: G = __r_arr[67];
+    let __v_197: G = __r_arr[68];
+    let __v_198: G = __r_arr[69];
+    let __v_199: G = __r_arr[70];
+    let __v_200: G = __r_arr[71];
+    let __v_201: G = __r_arr[72];
+    let __v_202: G = __r_arr[73];
+    let __v_203: G = __r_arr[74];
+    let __v_204: G = __r_arr[75];
+    let __v_205: G = __r_arr[76];
+    let __v_206: G = __r_arr[77];
+    let __v_207: G = __r_arr[78];
+    let __v_208: G = __r_arr[79];
+    let __v_209: G = __r_arr[80];
+    let __v_210: G = __r_arr[81];
+    let __v_211: G = __r_arr[82];
+    let __v_212: G = __r_arr[83];
+    let __v_213: G = __r_arr[84];
+    let __v_214: G = __r_arr[85];
+    let __v_215: G = __r_arr[86];
+    let __v_216: G = __r_arr[87];
+    let __v_217: G = __r_arr[88];
+    let __v_218: G = __r_arr[89];
+    let __v_219: G = __r_arr[90];
+    let __v_220: G = __r_arr[91];
+    let __v_221: G = __r_arr[92];
+    let __v_222: G = __r_arr[93];
+    let __v_223: G = __r_arr[94];
+    let __v_224: G = __r_arr[95];
+    let __v_225: G = __r_arr[96];
+    let __v_226: G = __r_arr[97];
+    let __v_227: G = __r_arr[98];
+    let __v_228: G = __r_arr[99];
+    let __v_229: G = __r_arr[100];
+    let __v_230: G = __r_arr[101];
+    let __v_231: G = __r_arr[102];
+    let __v_232: G = __r_arr[103];
+    let __v_233: G = __r_arr[104];
+    let __v_234: G = __r_arr[105];
+    let __v_235: G = __r_arr[106];
+    let __v_236: G = __r_arr[107];
+    let __v_237: G = __r_arr[108];
+    let __v_238: G = __r_arr[109];
+    let __v_239: G = __r_arr[110];
+    let __v_240: G = __r_arr[111];
+    let __v_241: G = __r_arr[112];
+    let __v_242: G = __r_arr[113];
+    let __v_243: G = __r_arr[114];
+    let __v_244: G = __r_arr[115];
+    let __v_245: G = __r_arr[116];
+    let __v_246: G = __r_arr[117];
+    let __v_247: G = __r_arr[118];
+    let __v_248: G = __r_arr[119];
+    let __v_249: G = __r_arr[120];
+    let __v_250: G = __r_arr[121];
+    let __v_251: G = __r_arr[122];
+    let __v_252: G = __r_arr[123];
+    let __v_253: G = __r_arr[124];
+    let __v_254: G = __r_arr[125];
+    let __v_255: G = __r_arr[126];
+    let __v_256: G = __r_arr[127];
+    let __v_257: G = if unconstrained { Bytes2::xor(&__v_129, &__v_161) } else { bytes2_xor_value(__v_129, __v_161, record) };
+    let __v_258: G = if unconstrained { Bytes2::xor(&__v_130, &__v_162) } else { bytes2_xor_value(__v_130, __v_162, record) };
+    let __v_259: G = if unconstrained { Bytes2::xor(&__v_131, &__v_163) } else { bytes2_xor_value(__v_131, __v_163, record) };
+    let __v_260: G = if unconstrained { Bytes2::xor(&__v_132, &__v_164) } else { bytes2_xor_value(__v_132, __v_164, record) };
+    let __v_261: G = if unconstrained { Bytes2::xor(&__v_133, &__v_165) } else { bytes2_xor_value(__v_133, __v_165, record) };
+    let __v_262: G = if unconstrained { Bytes2::xor(&__v_134, &__v_166) } else { bytes2_xor_value(__v_134, __v_166, record) };
+    let __v_263: G = if unconstrained { Bytes2::xor(&__v_135, &__v_167) } else { bytes2_xor_value(__v_135, __v_167, record) };
+    let __v_264: G = if unconstrained { Bytes2::xor(&__v_136, &__v_168) } else { bytes2_xor_value(__v_136, __v_168, record) };
+    let __v_265: G = if unconstrained { Bytes2::xor(&__v_137, &__v_169) } else { bytes2_xor_value(__v_137, __v_169, record) };
+    let __v_266: G = if unconstrained { Bytes2::xor(&__v_138, &__v_170) } else { bytes2_xor_value(__v_138, __v_170, record) };
+    let __v_267: G = if unconstrained { Bytes2::xor(&__v_139, &__v_171) } else { bytes2_xor_value(__v_139, __v_171, record) };
+    let __v_268: G = if unconstrained { Bytes2::xor(&__v_140, &__v_172) } else { bytes2_xor_value(__v_140, __v_172, record) };
+    let __v_269: G = if unconstrained { Bytes2::xor(&__v_141, &__v_173) } else { bytes2_xor_value(__v_141, __v_173, record) };
+    let __v_270: G = if unconstrained { Bytes2::xor(&__v_142, &__v_174) } else { bytes2_xor_value(__v_142, __v_174, record) };
+    let __v_271: G = if unconstrained { Bytes2::xor(&__v_143, &__v_175) } else { bytes2_xor_value(__v_143, __v_175, record) };
+    let __v_272: G = if unconstrained { Bytes2::xor(&__v_144, &__v_176) } else { bytes2_xor_value(__v_144, __v_176, record) };
+    let __v_273: G = if unconstrained { Bytes2::xor(&__v_145, &__v_177) } else { bytes2_xor_value(__v_145, __v_177, record) };
+    let __v_274: G = if unconstrained { Bytes2::xor(&__v_146, &__v_178) } else { bytes2_xor_value(__v_146, __v_178, record) };
+    let __v_275: G = if unconstrained { Bytes2::xor(&__v_147, &__v_179) } else { bytes2_xor_value(__v_147, __v_179, record) };
+    let __v_276: G = if unconstrained { Bytes2::xor(&__v_148, &__v_180) } else { bytes2_xor_value(__v_148, __v_180, record) };
+    let __v_277: G = if unconstrained { Bytes2::xor(&__v_149, &__v_181) } else { bytes2_xor_value(__v_149, __v_181, record) };
+    let __v_278: G = if unconstrained { Bytes2::xor(&__v_150, &__v_182) } else { bytes2_xor_value(__v_150, __v_182, record) };
+    let __v_279: G = if unconstrained { Bytes2::xor(&__v_151, &__v_183) } else { bytes2_xor_value(__v_151, __v_183, record) };
+    let __v_280: G = if unconstrained { Bytes2::xor(&__v_152, &__v_184) } else { bytes2_xor_value(__v_152, __v_184, record) };
+    let __v_281: G = if unconstrained { Bytes2::xor(&__v_153, &__v_185) } else { bytes2_xor_value(__v_153, __v_185, record) };
+    let __v_282: G = if unconstrained { Bytes2::xor(&__v_154, &__v_186) } else { bytes2_xor_value(__v_154, __v_186, record) };
+    let __v_283: G = if unconstrained { Bytes2::xor(&__v_155, &__v_187) } else { bytes2_xor_value(__v_155, __v_187, record) };
+    let __v_284: G = if unconstrained { Bytes2::xor(&__v_156, &__v_188) } else { bytes2_xor_value(__v_156, __v_188, record) };
+    let __v_285: G = if unconstrained { Bytes2::xor(&__v_157, &__v_189) } else { bytes2_xor_value(__v_157, __v_189, record) };
+    let __v_286: G = if unconstrained { Bytes2::xor(&__v_158, &__v_190) } else { bytes2_xor_value(__v_158, __v_190, record) };
+    let __v_287: G = if unconstrained { Bytes2::xor(&__v_159, &__v_191) } else { bytes2_xor_value(__v_159, __v_191, record) };
+    let __v_288: G = if unconstrained { Bytes2::xor(&__v_160, &__v_192) } else { bytes2_xor_value(__v_160, __v_192, record) };
+    let __ret: [G; OUT_32] = [__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];
+    record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_30: usize = 0;
-const IN_30: usize = 0;
-const OUT_30: usize = 22;
-fn aiur_fn_30(
-  inp: [G; IN_30],
+const INPUT_SIZE_33: usize = 0;
+const IN_33: usize = 0;
+const OUT_33: usize = 22;
+fn aiur_fn_33(
+  inp: [G; IN_33],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_30], ExecError> {
+) -> Result<[G; OUT_33], 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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     let __v_6: G = __r_arr[2];
@@ -6688,13 +6131,13 @@ fn aiur_fn_30(
     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_770] = { let __args: [G; IN_770] = [__v_10, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_10, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = 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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     let __v_17: G = __r_arr[1];
     let __v_18: G = __r_arr[2];
@@ -6703,7 +6146,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_24: G = __r_arr[0];
     let __v_25: G = __r_arr[1];
     let __v_26: G = __r_arr[2];
@@ -6712,7 +6155,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_32: G = __r_arr[0];
     let __v_33: G = __r_arr[1];
     let __v_34: G = __r_arr[2];
@@ -6720,19 +6163,19 @@ fn aiur_fn_30(
     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_770] = { let __args: [G; IN_770] = [__v_38, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_38, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_39: G = __r_arr[0];
     let __v_40: G = G::from_u64(10);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_40, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_40, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_41: G = __r_arr[0];
     let __v_42: G = G::from_u64(20);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_42, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_42, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_48: G = __r_arr[0];
     let __v_49: G = __r_arr[1];
     let __v_50: G = __r_arr[2];
@@ -6741,7 +6184,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_56: G = __r_arr[0];
     let __v_57: G = __r_arr[1];
     let __v_58: G = __r_arr[2];
@@ -6749,13 +6192,13 @@ fn aiur_fn_30(
     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_770] = { let __args: [G; IN_770] = [__v_62, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_62, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_68: G = __r_arr[0];
     let __v_69: G = __r_arr[1];
     let __v_70: G = __r_arr[2];
@@ -6764,7 +6207,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_76: G = __r_arr[0];
     let __v_77: G = __r_arr[1];
     let __v_78: G = __r_arr[2];
@@ -6773,7 +6216,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_84: G = __r_arr[0];
     let __v_85: G = __r_arr[1];
     let __v_86: G = __r_arr[2];
@@ -6782,7 +6225,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_92: G = __r_arr[0];
     let __v_93: G = __r_arr[1];
     let __v_94: G = __r_arr[2];
@@ -6791,7 +6234,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_100: G = __r_arr[0];
     let __v_101: G = __r_arr[1];
     let __v_102: G = __r_arr[2];
@@ -6799,25 +6242,25 @@ fn aiur_fn_30(
     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_770] = { let __args: [G; IN_770] = [__v_106, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_106, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_107: G = __r_arr[0];
     let __v_108: G = G::from_u64(2);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_108, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_108, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_109: G = __r_arr[0];
     let __v_110: G = G::from_u64(3);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_110, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_110, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_111: G = __r_arr[0];
     let __v_112: G = G::from_u64(4);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_112, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_112, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_113: G = __r_arr[0];
     let __v_114: G = G::from_u64(5);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_114, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_114, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_120: G = __r_arr[0];
     let __v_121: G = __r_arr[1];
     let __v_122: G = __r_arr[2];
@@ -6826,7 +6269,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_128: G = __r_arr[0];
     let __v_129: G = __r_arr[1];
     let __v_130: G = __r_arr[2];
@@ -6835,7 +6278,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_136: G = __r_arr[0];
     let __v_137: G = __r_arr[1];
     let __v_138: G = __r_arr[2];
@@ -6844,7 +6287,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_144: G = __r_arr[0];
     let __v_145: G = __r_arr[1];
     let __v_146: G = __r_arr[2];
@@ -6853,7 +6296,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_152: G = __r_arr[0];
     let __v_153: G = __r_arr[1];
     let __v_154: G = __r_arr[2];
@@ -6861,25 +6304,25 @@ fn aiur_fn_30(
     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_770] = { let __args: [G; IN_770] = [__v_158, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_158, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_159: G = __r_arr[0];
     let __v_160: G = G::from_u64(2);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_160, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_160, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_161: G = __r_arr[0];
     let __v_162: G = G::from_u64(3);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_162, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_162, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_163: G = __r_arr[0];
     let __v_164: G = G::from_u64(4);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_164, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_164, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_165: G = __r_arr[0];
     let __v_166: G = G::from_u64(5);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_166, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_166, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_172: G = __r_arr[0];
     let __v_173: G = __r_arr[1];
     let __v_174: G = __r_arr[2];
@@ -6888,7 +6331,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_180: G = __r_arr[0];
     let __v_181: G = __r_arr[1];
     let __v_182: G = __r_arr[2];
@@ -6897,7 +6340,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_188: G = __r_arr[0];
     let __v_189: G = __r_arr[1];
     let __v_190: G = __r_arr[2];
@@ -6906,7 +6349,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_196: G = __r_arr[0];
     let __v_197: G = __r_arr[1];
     let __v_198: G = __r_arr[2];
@@ -6915,7 +6358,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_204: G = __r_arr[0];
     let __v_205: G = __r_arr[1];
     let __v_206: G = __r_arr[2];
@@ -6924,7 +6367,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_212: G = __r_arr[0];
     let __v_213: G = __r_arr[1];
     let __v_214: G = __r_arr[2];
@@ -6933,7 +6376,7 @@ fn aiur_fn_30(
     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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_220: G = __r_arr[0];
     let __v_221: G = __r_arr[1];
     let __v_222: G = __r_arr[2];
@@ -6941,41 +6384,41 @@ fn aiur_fn_30(
     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_770] = { let __args: [G; IN_770] = [__v_226, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_226, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_227: G = __r_arr[0];
     let __v_228: G = G::from_u64(30);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_228, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_228, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_229: G = __r_arr[0];
     let __v_230: G = G::from_u64(40);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_230, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_230, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_231: G = __r_arr[0];
     let __v_232: G = G::from_u64(50);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_232, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_232, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_233: G = __r_arr[0];
     let __v_234: G = G::from_u64(60);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_234, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_234, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_235: G = __r_arr[0];
     let __v_236: G = G::from_u64(70);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_236, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_236, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_237: G = __r_arr[0];
     let __v_238: G = G::from_u64(80);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_238, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_238, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_239: G = __r_arr[0];
-    let __ret: [G; OUT_30] = [__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[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_33] = [__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[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_31: usize = 19;
-const IN_31: usize = 19;
-const OUT_31: usize = 1;
-fn aiur_fn_31(
-  inp: [G; IN_31],
+const INPUT_SIZE_34: usize = 19;
+const IN_34: usize = 19;
+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_31], ExecError> {
+) -> Result<[G; OUT_34], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -6999,22 +6442,22 @@ fn aiur_fn_31(
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_20];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_20];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_19: G = G::from_u64(1);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_20];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_20];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7024,18 +6467,18 @@ fn aiur_fn_31(
         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_36] = { let __args: [G; IN_36] = [__v_9, __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 __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_30: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_30];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_30];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7045,14 +6488,14 @@ fn aiur_fn_31(
         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_36] = { let __args: [G; IN_36] = [__v_9, __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 __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_30: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_30];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_30];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
@@ -7076,34 +6519,34 @@ fn aiur_fn_31(
         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_31] = { let __args: [G; IN_31] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_39: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_40: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_40];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_40];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_19: G = G::from_u64(5);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_20];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_20];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_19: G = G::from_u64(6);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_20];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_20];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __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[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 __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];
@@ -7113,16 +6556,16 @@ fn aiur_fn_31(
         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_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, __v_18]; 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 __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_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_29];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_29];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        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 __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7132,16 +6575,16 @@ fn aiur_fn_31(
         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_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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_29];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_29];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       9u64 => {
-        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 __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7151,12 +6594,12 @@ fn aiur_fn_31(
         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_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 __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_29];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_29];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       10u64 => {
@@ -7218,24 +6661,24 @@ fn aiur_fn_31(
         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_31] = { let __args: [G; IN_31] = [__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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !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_31] = { let __args: [G; IN_31] = [__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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !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_31] = { let __args: [G; IN_31] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !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_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_77: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_77];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_77];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       11u64 => {
         let __v_19: G = G::from_u64(11);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_20];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_20];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7245,15 +6688,15 @@ fn aiur_fn_31(
   })
 }
 
-const INPUT_SIZE_32: usize = 10;
-const IN_32: usize = 10;
-const OUT_32: usize = 1;
-fn aiur_fn_32(
-  inp: [G; IN_32],
+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_32], ExecError> {
+) -> 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];
@@ -7267,8 +6710,8 @@ fn aiur_fn_32(
     let __v_9: G = inp[9];
     match __v_8.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_32] = [__v_9];
-        record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_9];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7276,26 +6719,26 @@ fn aiur_fn_32(
         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_32] = { let __args: [G; IN_32] = [__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[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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_32] = [__v_15];
-        record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_15];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_33: usize = 9;
-const IN_33: usize = 9;
-const OUT_33: usize = 1;
-fn aiur_fn_33(
-  inp: [G; IN_33],
+const INPUT_SIZE_36: usize = 9;
+const IN_36: usize = 9;
+const OUT_36: usize = 1;
+fn aiur_fn_36(
+  inp: [G; IN_36],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_33], ExecError> {
+) -> Result<[G; OUT_36], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7316,8 +6759,8 @@ fn aiur_fn_33(
           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_33] = [__v_13];
-            record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_36] = [__v_13];
+            record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -7326,11 +6769,11 @@ fn aiur_fn_33(
             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_32] = { let __args: [G; IN_32] = [__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[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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_33] = [__v_18];
-            record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_36] = [__v_18];
+            record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -7341,26 +6784,26 @@ fn aiur_fn_33(
         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_32] = { let __args: [G; IN_32] = [__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[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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
         let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_33] = [__v_18];
-        record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_36] = [__v_18];
+        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_34: usize = 10;
-const IN_34: usize = 10;
-const OUT_34: usize = 1;
-fn aiur_fn_34(
-  inp: [G; IN_34],
+const INPUT_SIZE_37: usize = 10;
+const IN_37: usize = 10;
+const OUT_37: usize = 1;
+fn aiur_fn_37(
+  inp: [G; IN_37],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_34], ExecError> {
+) -> Result<[G; OUT_37], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7385,8 +6828,8 @@ fn aiur_fn_34(
             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_34] = [__v_17];
-            record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_37] = [__v_17];
+            record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -7398,11 +6841,11 @@ fn aiur_fn_34(
             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_32] = { let __args: [G; IN_32] = [__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[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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_34] = [__v_22];
-            record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_37] = [__v_22];
+            record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -7416,26 +6859,26 @@ fn aiur_fn_34(
         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_32] = { let __args: [G; IN_32] = [__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[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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_34] = [__v_22];
-        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_37] = [__v_22];
+        record.function_queries[37].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],
+const INPUT_SIZE_38: usize = 10;
+const IN_38: usize = 10;
+const OUT_38: usize = 1;
+fn aiur_fn_38(
+  inp: [G; IN_38],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_35], ExecError> {
+) -> Result<[G; OUT_38], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7460,8 +6903,8 @@ fn aiur_fn_35(
             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));
+            let __ret: [G; OUT_38] = [__v_17];
+            record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -7473,11 +6916,11 @@ 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_32] = { let __args: [G; IN_32] = [__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[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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_35] = [__v_22];
-            record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_38] = [__v_22];
+            record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -7491,26 +6934,26 @@ 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_32] = { let __args: [G; IN_32] = [__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[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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_35] = [__v_22];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_38] = [__v_22];
+        record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_36: usize = 2;
-const IN_36: usize = 2;
-const OUT_36: usize = 1;
-fn aiur_fn_36(
-  inp: [G; IN_36],
+const INPUT_SIZE_39: usize = 2;
+const IN_39: usize = 2;
+const OUT_39: usize = 1;
+fn aiur_fn_39(
+  inp: [G; IN_39],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_36], ExecError> {
+) -> Result<[G; OUT_39], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7527,17 +6970,17 @@ fn aiur_fn_36(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_36] = [__v_1];
-        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_39] = [__v_1];
+        record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_11, __v_1]; 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 __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_36] = [__v_13];
-        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_39] = [__v_13];
+        record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7547,15 +6990,15 @@ fn aiur_fn_36(
   })
 }
 
-const INPUT_SIZE_37: usize = 18;
-const IN_37: usize = 18;
-const OUT_37: usize = 8;
-fn aiur_fn_37(
-  inp: [G; IN_37],
+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_37], ExecError> {
+) -> Result<[G; OUT_40], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7596,7 +7039,7 @@ fn aiur_fn_37(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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 __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];
@@ -7605,7 +7048,7 @@ fn aiur_fn_37(
         let __v_41: G = __r_arr[5];
         let __v_42: G = __r_arr[6];
         let __v_43: G = __r_arr[7];
-        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -7614,8 +7057,8 @@ fn aiur_fn_37(
         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_37] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_40] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7627,23 +7070,23 @@ fn aiur_fn_37(
         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_37] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_38: usize = 18;
-const IN_38: usize = 18;
-const OUT_38: usize = 8;
-fn aiur_fn_38(
-  inp: [G; IN_38],
+const INPUT_SIZE_41: usize = 18;
+const IN_41: usize = 18;
+const OUT_41: usize = 8;
+fn aiur_fn_41(
+  inp: [G; IN_41],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_38], ExecError> {
+) -> Result<[G; OUT_41], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7684,7 +7127,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; 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 __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
         let __v_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -7693,7 +7136,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; 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 __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -7702,8 +7145,8 @@ fn aiur_fn_38(
         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));
+        let __ret: [G; OUT_41] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7715,23 +7158,23 @@ fn aiur_fn_38(
         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));
+        let __ret: [G; OUT_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        record.function_queries[41].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],
+const INPUT_SIZE_42: usize = 18;
+const IN_42: usize = 18;
+const OUT_42: usize = 8;
+fn aiur_fn_42(
+  inp: [G; IN_42],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_39], ExecError> {
+) -> Result<[G; OUT_42], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7772,7 +7215,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; 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 __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
         let __v_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -7781,7 +7224,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; 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 __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -7790,8 +7233,8 @@ fn aiur_fn_39(
         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));
+        let __ret: [G; OUT_42] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7803,23 +7246,23 @@ fn aiur_fn_39(
         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));
+        let __ret: [G; OUT_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_40: usize = 19;
-const IN_40: usize = 19;
-const OUT_40: usize = 1;
-fn aiur_fn_40(
-  inp: [G; IN_40],
+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_40], ExecError> {
+) -> Result<[G; OUT_43], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7880,34 +7323,34 @@ fn aiur_fn_40(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !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_40] = { let __args: [G; IN_40] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[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 __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } else { aiur_fn_43(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __ret: [G; OUT_40] = [__v_56];
-        record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_31] = { let __args: [G; IN_31] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_40] = [__v_19];
-        record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_43] = [__v_19];
+        record.function_queries[43].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],
+const INPUT_SIZE_44: usize = 19;
+const IN_44: usize = 19;
+const OUT_44: usize = 1;
+fn aiur_fn_44(
+  inp: [G; IN_44],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_41], ExecError> {
+) -> Result<[G; OUT_44], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7968,34 +7411,34 @@ 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_41] = { let __args: [G; IN_41] = [__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[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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __ret: [G; OUT_41] = [__v_56];
-        record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_44] = [__v_56];
+        record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_41] = [__v_19];
-        record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_44] = [__v_19];
+        record.function_queries[44].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],
+const INPUT_SIZE_45: usize = 19;
+const IN_45: usize = 19;
+const OUT_45: usize = 1;
+fn aiur_fn_45(
+  inp: [G; IN_45],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_42], ExecError> {
+) -> Result<[G; OUT_45], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8056,34 +7499,34 @@ 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; 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 __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __ret: [G; OUT_42] = [__v_56];
-        record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_45] = [__v_56];
+        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_42] = [__v_19];
-        record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_45] = [__v_19];
+        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_43: usize = 2;
-const IN_43: usize = 2;
-const OUT_43: usize = 1;
-fn aiur_fn_43(
-  inp: [G; IN_43],
+const INPUT_SIZE_46: usize = 2;
+const IN_46: usize = 2;
+const OUT_46: usize = 1;
+fn aiur_fn_46(
+  inp: [G; IN_46],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_43], ExecError> {
+) -> Result<[G; OUT_46], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8184,21 +7627,21 @@ fn aiur_fn_43(
     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_43] = [__v_97];
-    record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_46] = [__v_97];
+    record.function_queries[46].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],
+const INPUT_SIZE_47: usize = 2;
+const IN_47: usize = 2;
+const OUT_47: usize = 1;
+fn aiur_fn_47(
+  inp: [G; IN_47],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_44], ExecError> {
+) -> Result<[G; OUT_47], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8207,20 +7650,20 @@ fn aiur_fn_44(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_47] = [__v_2];
+            record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_47] = [__v_2];
+            record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(2);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_47] = [__v_2];
+            record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -8232,20 +7675,20 @@ fn aiur_fn_44(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(4);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_47] = [__v_2];
+            record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(5);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_47] = [__v_2];
+            record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(6);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_47] = [__v_2];
+            record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -8257,20 +7700,20 @@ fn aiur_fn_44(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(8);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_47] = [__v_2];
+            record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(9);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_47] = [__v_2];
+            record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(10);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_47] = [__v_2];
+            record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -8285,15 +7728,15 @@ fn aiur_fn_44(
   })
 }
 
-const INPUT_SIZE_45: usize = 9;
-const IN_45: usize = 9;
-const OUT_45: usize = 8;
-fn aiur_fn_45(
-  inp: [G; IN_45],
+const INPUT_SIZE_48: usize = 9;
+const IN_48: usize = 9;
+const OUT_48: usize = 8;
+fn aiur_fn_48(
+  inp: [G; IN_48],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_45], ExecError> {
+) -> Result<[G; OUT_48], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8316,7 +7759,7 @@ fn aiur_fn_45(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__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[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 __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -8325,7 +7768,7 @@ fn aiur_fn_45(
         let __v_23: G = __r_arr[5];
         let __v_24: G = __r_arr[6];
         let __v_25: G = __r_arr[7];
-        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_8] = { let __args: [G; IN_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[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_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
@@ -8334,8 +7777,8 @@ fn aiur_fn_45(
         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_45] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_48] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
+        record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8347,23 +7790,23 @@ fn aiur_fn_45(
         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_45] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
-        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
+        record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_46: usize = 9;
-const IN_46: usize = 9;
-const OUT_46: usize = 9;
-fn aiur_fn_46(
-  inp: [G; IN_46],
+const INPUT_SIZE_49: usize = 9;
+const IN_49: usize = 9;
+const OUT_49: usize = 9;
+fn aiur_fn_49(
+  inp: [G; IN_49],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_46], ExecError> {
+) -> Result<[G; OUT_49], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8386,7 +7829,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; 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 __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } else { aiur_fn_49(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -8396,28 +7839,28 @@ fn aiur_fn_46(
         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_46] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_49] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_47: usize = 10;
-const IN_47: usize = 10;
-const OUT_47: usize = 1;
-fn aiur_fn_47(
-  inp: [G; IN_47],
+const INPUT_SIZE_50: usize = 10;
+const IN_50: usize = 10;
+const OUT_50: usize = 1;
+fn aiur_fn_50(
+  inp: [G; IN_50],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_47], ExecError> {
+) -> Result<[G; OUT_50], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8434,12 +7877,12 @@ fn aiur_fn_47(
         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_47] = [__v_12];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_50] = [__v_12];
+        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -8448,7 +7891,7 @@ fn aiur_fn_47(
         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_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 __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } else { aiur_fn_49(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -8459,12 +7902,12 @@ fn aiur_fn_47(
         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_47] = { let __args: [G; IN_47] = [__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[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 __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[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 __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_47] = [__v_29];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_50] = [__v_29];
+        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
@@ -8497,14 +7940,14 @@ fn aiur_fn_47(
         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_47] = { let __args: [G; IN_47] = [__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[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 __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__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[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 __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_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 __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
         let __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_47] = [__v_39];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_50] = [__v_39];
+        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
@@ -8537,22 +7980,22 @@ fn aiur_fn_47(
         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_47] = { let __args: [G; IN_47] = [__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[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 __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__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[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 __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_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 __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
         let __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_47] = [__v_39];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_50] = [__v_39];
+        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_10: G = G::from_u64(3);
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[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 __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_47] = [__v_11];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_50] = [__v_11];
+        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8562,15 +8005,15 @@ fn aiur_fn_47(
   })
 }
 
-const INPUT_SIZE_48: usize = 2;
-const IN_48: usize = 2;
-const OUT_48: usize = 1;
-fn aiur_fn_48(
-  inp: [G; IN_48],
+const INPUT_SIZE_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_48], ExecError> {
+) -> Result<[G; OUT_51], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8580,8 +8023,8 @@ fn aiur_fn_48(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_48] = [__v_1];
-        record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_51] = [__v_1];
+        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -8604,12 +8047,12 @@ fn aiur_fn_48(
         let __v_20: G = __loaded[15];
         let __v_21: G = __loaded[16];
         let __v_22: G = __loaded[17];
-        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_4, __v_1]; 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 __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_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __ret: [G; OUT_48] = [__v_24];
-        record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_51] = [__v_24];
+        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8619,15 +8062,15 @@ fn aiur_fn_48(
   })
 }
 
-const INPUT_SIZE_49: usize = 2;
-const IN_49: usize = 2;
-const OUT_49: usize = 1;
-fn aiur_fn_49(
-  inp: [G; IN_49],
+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_49], ExecError> {
+) -> Result<[G; OUT_52], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8637,8 +8080,8 @@ fn aiur_fn_49(
     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));
+        let __ret: [G; OUT_52] = [__v_1];
+        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -8652,12 +8095,12 @@ fn aiur_fn_49(
         let __v_11: G = __loaded[6];
         let __v_12: G = __loaded[7];
         let __v_13: G = __loaded[8];
-        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 __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } else { aiur_fn_52(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__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[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 __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_49] = [__v_15];
-        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_52] = [__v_15];
+        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8667,15 +8110,15 @@ fn aiur_fn_49(
   })
 }
 
-const INPUT_SIZE_50: usize = 2;
-const IN_50: usize = 2;
-const OUT_50: usize = 1;
-fn aiur_fn_50(
-  inp: [G; IN_50],
+const INPUT_SIZE_53: usize = 2;
+const IN_53: usize = 2;
+const OUT_53: usize = 1;
+fn aiur_fn_53(
+  inp: [G; IN_53],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_50], ExecError> {
+) -> Result<[G; OUT_53], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8685,17 +8128,17 @@ fn aiur_fn_50(
     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));
+        let __ret: [G; OUT_53] = [__v_1];
+        record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } else { aiur_fn_43(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_50] = [__v_6];
-        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_53] = [__v_6];
+        record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8705,15 +8148,15 @@ fn aiur_fn_50(
   })
 }
 
-const INPUT_SIZE_51: usize = 2;
-const IN_51: usize = 2;
-const OUT_51: usize = 1;
-fn aiur_fn_51(
-  inp: [G; IN_51],
+const INPUT_SIZE_54: usize = 2;
+const IN_54: usize = 2;
+const OUT_54: usize = 1;
+fn aiur_fn_54(
+  inp: [G; IN_54],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_51], ExecError> {
+) -> Result<[G; OUT_54], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8722,32 +8165,32 @@ fn aiur_fn_51(
         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_51] = [__v_4];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_54] = [__v_4];
+        record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_2: G = G::from_u64(0);
         let __v_3: G = G::from_u64(1);
         let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_51] = [__v_4];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_54] = [__v_4];
+        record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_2: G = G::from_u64(0);
         let __v_3: G = G::from_u64(2);
         let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_51] = [__v_4];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_54] = [__v_4];
+        record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_2: G = G::from_u64(0);
         let __v_3: G = G::from_u64(3);
         let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_51] = [__v_4];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_54] = [__v_4];
+        record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8757,15 +8200,15 @@ fn aiur_fn_51(
   })
 }
 
-const INPUT_SIZE_52: usize = 13;
-const IN_52: usize = 13;
-const OUT_52: usize = 1;
-fn aiur_fn_52(
-  inp: [G; IN_52],
+const INPUT_SIZE_55: usize = 13;
+const IN_55: usize = 13;
+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_52], ExecError> {
+) -> Result<[G; OUT_55], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8820,33 +8263,33 @@ fn aiur_fn_52(
         let __v_46: G = __loaded[15];
         let __v_47: G = __loaded[16];
         let __v_48: G = __loaded[17];
-        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } else { aiur_fn_47(__args, record, io_buffer, __cu)? } };
         let __v_49: G = __r_arr[0];
         let __v_50: G = G::from_u64(0);
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_31, __v_32, __v_33, __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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_51: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_52: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_53: G = __r_arr[0];
         let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_52] = [__v_54];
-        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_55] = [__v_54];
+        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_53: usize = 10;
-const IN_53: usize = 10;
-const OUT_53: usize = 1;
-fn aiur_fn_53(
-  inp: [G; IN_53],
+const INPUT_SIZE_56: usize = 10;
+const IN_56: usize = 10;
+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_53], ExecError> {
+) -> Result<[G; OUT_56], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8879,27 +8322,27 @@ fn aiur_fn_53(
         let __v_25: G = __loaded[15];
         let __v_26: G = __loaded[16];
         let __v_27: G = __loaded[17];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !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_53] = [__v_29];
-        record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_56] = [__v_29];
+        record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_54: usize = 2;
-const IN_54: usize = 2;
-const OUT_54: usize = 1;
-fn aiur_fn_54(
-  inp: [G; IN_54],
+const INPUT_SIZE_57: usize = 2;
+const IN_57: usize = 2;
+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_54], ExecError> {
+) -> Result<[G; OUT_57], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8917,17 +8360,17 @@ fn aiur_fn_54(
     let __v_12: G = __loaded[10];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_54] = [__v_1];
-        record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_57] = [__v_1];
+        record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_12, __v_1]; 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 __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__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[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 __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !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_14: G = __r_arr[0];
-        let __ret: [G; OUT_54] = [__v_14];
-        record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_57] = [__v_14];
+        record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8937,15 +8380,15 @@ fn aiur_fn_54(
   })
 }
 
-const INPUT_SIZE_55: usize = 45;
-const IN_55: usize = 45;
-const OUT_55: usize = 1;
-fn aiur_fn_55(
-  inp: [G; IN_55],
+const INPUT_SIZE_58: usize = 45;
+const IN_58: usize = 45;
+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_55], ExecError> {
+) -> Result<[G; OUT_58], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9016,7 +8459,7 @@ fn aiur_fn_55(
         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_775] = { let __args: [G; IN_775] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
         let __v_66: G = __r_arr[0];
         let __v_67: G = __r_arr[1];
         let __v_68: G = __r_arr[2];
@@ -9026,40 +8469,40 @@ fn aiur_fn_55(
         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_54] = { let __args: [G; IN_54] = [__v_43, __v_44]; 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 __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } };
         let __v_75: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_76: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_77: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_78: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_79: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_80: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_81: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_82: G = __r_arr[0];
         let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_55] = [__v_83];
-        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_58] = [__v_83];
+        record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_56: usize = 11;
-const IN_56: usize = 11;
-const OUT_56: usize = 1;
-fn aiur_fn_56(
-  inp: [G; IN_56],
+const INPUT_SIZE_59: usize = 11;
+const IN_59: usize = 11;
+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_56], ExecError> {
+) -> Result<[G; OUT_59], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9094,28 +8537,28 @@ fn aiur_fn_56(
         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_31] = { let __args: [G; IN_31] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !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_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_31: G = __r_arr[0];
         let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_56] = [__v_32];
-        record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_59] = [__v_32];
+        record.function_queries[59].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],
+const INPUT_SIZE_60: usize = 11;
+const IN_60: usize = 11;
+const OUT_60: usize = 1;
+fn aiur_fn_60(
+  inp: [G; IN_60],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_57], ExecError> {
+) -> Result<[G; OUT_60], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9149,29 +8592,29 @@ fn aiur_fn_57(
         let __v_26: G = __loaded[15];
         let __v_27: G = __loaded[16];
         let __v_28: G = __loaded[17];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !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_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_30]; 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 __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
         let __v_31: G = __r_arr[0];
-        let __ret: [G; OUT_57] = [__v_31];
-        record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_60] = [__v_31];
+        record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_58: usize = 35;
-const IN_58: usize = 35;
-const OUT_58: usize = 1;
-fn aiur_fn_58(
-  inp: [G; IN_58],
+const INPUT_SIZE_61: usize = 35;
+const IN_61: usize = 35;
+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_58], ExecError> {
+) -> Result<[G; OUT_61], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9230,34 +8673,34 @@ fn aiur_fn_58(
         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_31] = { let __args: [G; IN_31] = [__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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_54: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_58: G = __r_arr[0];
         let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_58] = [__v_59];
-        record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_59];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_59: usize = 2;
-const IN_59: usize = 2;
-const OUT_59: usize = 1;
-fn aiur_fn_59(
-  inp: [G; IN_59],
+const INPUT_SIZE_62: usize = 2;
+const IN_62: usize = 2;
+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_59], ExecError> {
+) -> Result<[G; OUT_62], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9300,17 +8743,17 @@ fn aiur_fn_59(
     let __v_37: G = __loaded[35];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_59] = [__v_1];
-        record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_62] = [__v_1];
+        record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_37, __v_1]; 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 __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[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 __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !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_39: G = __r_arr[0];
-        let __ret: [G; OUT_59] = [__v_39];
-        record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_62] = [__v_39];
+        record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9320,15 +8763,15 @@ fn aiur_fn_59(
   })
 }
 
-const INPUT_SIZE_60: usize = 28;
-const IN_60: usize = 28;
-const OUT_60: usize = 1;
-fn aiur_fn_60(
-  inp: [G; IN_60],
+const INPUT_SIZE_63: usize = 28;
+const IN_63: usize = 28;
+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_60], ExecError> {
+) -> Result<[G; OUT_63], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9379,7 +8822,7 @@ fn aiur_fn_60(
         let __v_43: G = __loaded[15];
         let __v_44: G = __loaded[16];
         let __v_45: G = __loaded[17];
-        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
         let __v_47: G = __r_arr[1];
         let __v_48: G = __r_arr[2];
@@ -9389,36 +8832,36 @@ fn aiur_fn_60(
         let __v_52: G = __r_arr[6];
         let __v_53: G = __r_arr[7];
         let __v_54: G = G::from_u64(0);
-        let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_26, __v_27]; 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 __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !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_33] = { let __args: [G; IN_33] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_58: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_59: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_60: G = __r_arr[0];
         let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_60] = [__v_61];
-        record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_63] = [__v_61];
+        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_61: usize = 10;
-const IN_61: usize = 10;
-const OUT_61: usize = 1;
-fn aiur_fn_61(
-  inp: [G; IN_61],
+const INPUT_SIZE_64: usize = 10;
+const IN_64: usize = 10;
+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_61], ExecError> {
+) -> Result<[G; OUT_64], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9432,27 +8875,27 @@ fn aiur_fn_61(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_11];
-        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_64] = [__v_11];
+        record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_62: usize = 18;
-const IN_62: usize = 18;
-const OUT_62: usize = 1;
-fn aiur_fn_62(
-  inp: [G; IN_62],
+const INPUT_SIZE_65: usize = 18;
+const IN_65: usize = 18;
+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_62], ExecError> {
+) -> Result<[G; OUT_65], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9474,29 +8917,29 @@ fn aiur_fn_62(
     let __v_17: G = inp[17];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_16, __v_17]; 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 __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !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_62] = [__v_20];
-        record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_65] = [__v_20];
+        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_63: usize = 46;
-const IN_63: usize = 46;
-const OUT_63: usize = 1;
-fn aiur_fn_63(
-  inp: [G; IN_63],
+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_63], ExecError> {
+) -> Result<[G; OUT_66], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9548,31 +8991,31 @@ fn aiur_fn_63(
       0u64 => {
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(0);
-        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_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[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 __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !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_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_63] = [__v_49];
-        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_66] = [__v_49];
+        record.function_queries[66].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_60] = { let __args: [G; IN_60] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !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_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_63] = [__v_49];
-        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_66] = [__v_49];
+        record.function_queries[66].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_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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 __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !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_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_63] = [__v_49];
-        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_66] = [__v_49];
+        record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9582,15 +9025,15 @@ fn aiur_fn_63(
   })
 }
 
-const INPUT_SIZE_64: usize = 2;
-const IN_64: usize = 2;
-const OUT_64: usize = 1;
-fn aiur_fn_64(
-  inp: [G; IN_64],
+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_64], ExecError> {
+) -> Result<[G; OUT_67], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9644,17 +9087,17 @@ fn aiur_fn_64(
     let __v_48: G = __loaded[46];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_64] = [__v_1];
-        record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_67] = [__v_1];
+        record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_48, __v_1]; 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 __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !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_49: G = __r_arr[0];
-        let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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 __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !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_50: G = __r_arr[0];
-        let __ret: [G; OUT_64] = [__v_50];
-        record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_67] = [__v_50];
+        record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9664,15 +9107,15 @@ fn aiur_fn_64(
   })
 }
 
-const INPUT_SIZE_65: usize = 46;
-const IN_65: usize = 46;
-const OUT_65: usize = 1;
-fn aiur_fn_65(
-  inp: [G; IN_65],
+const INPUT_SIZE_68: usize = 46;
+const IN_68: usize = 46;
+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_65], ExecError> {
+) -> Result<[G; OUT_68], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9722,59 +9165,59 @@ fn aiur_fn_65(
     let __v_45: G = inp[45];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_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[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 __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !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_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_68] = [__v_46];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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 __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !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_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_68] = [__v_46];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        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_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 __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } else { aiur_fn_59(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_68] = [__v_46];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        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 __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } else { aiur_fn_60(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_68] = [__v_46];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        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_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[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 __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_68] = [__v_46];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        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_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 __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !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_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_68] = [__v_46];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        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_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 __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !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_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_68] = [__v_46];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        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_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 __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !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_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_68] = [__v_46];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9784,19 +9227,19 @@ fn aiur_fn_65(
   })
 }
 
-const INPUT_SIZE_66: usize = 2;
-const IN_66: usize = 2;
-const OUT_66: usize = 1;
-fn aiur_fn_66(
-  inp: [G; IN_66],
+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_66], ExecError> {
+) -> Result<[G; OUT_69], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } else { aiur_fn_761(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -9805,29 +9248,29 @@ fn aiur_fn_66(
     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_48] = { let __args: [G; IN_48] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_66] = [__v_11];
-    record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_69] = [__v_11];
+    record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_67: usize = 2;
-const IN_67: usize = 2;
-const OUT_67: usize = 1;
-fn aiur_fn_67(
-  inp: [G; IN_67],
+const INPUT_SIZE_70: usize = 2;
+const IN_70: usize = 2;
+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_67], ExecError> {
+) -> 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 __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } else { aiur_fn_761(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -9836,29 +9279,29 @@ 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_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 __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_67] = [__v_11];
-    record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_70] = [__v_11];
+    record.function_queries[70].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],
+const INPUT_SIZE_71: usize = 2;
+const IN_71: usize = 2;
+const OUT_71: usize = 1;
+fn aiur_fn_71(
+  inp: [G; IN_71],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_68], ExecError> {
+) -> Result<[G; OUT_71], 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_761] = { let __args: [G; IN_761] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } else { aiur_fn_761(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -9867,25 +9310,25 @@ 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_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 __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } else { aiur_fn_52(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_68] = [__v_11];
-    record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_71] = [__v_11];
+    record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_69: usize = 49;
-const IN_69: usize = 49;
-const OUT_69: usize = 1;
-fn aiur_fn_69(
-  inp: [G; IN_69],
+const INPUT_SIZE_72: usize = 49;
+const IN_72: usize = 49;
+const OUT_72: usize = 1;
+fn aiur_fn_72(
+  inp: [G; IN_72],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_69], ExecError> {
+) -> 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];
@@ -9938,15 +9381,15 @@ fn aiur_fn_69(
     let __v_48: G = inp[48];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_47, __v_48]; 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 __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !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 __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_46, __v_49]; 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !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_50: G = __r_arr[0];
-        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_45, __v_50]; 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 __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_45, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !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_51: G = __r_arr[0];
         match __v_0.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
             let __v_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
             let __v_54: G = __r_arr[2];
@@ -9956,12 +9399,12 @@ fn aiur_fn_69(
             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_64] = { let __args: [G; IN_64] = [__v_1, __v_51]; 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 __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_72] = [__v_62];
+            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -9974,12 +9417,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_72] = [__v_62];
+            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
@@ -9992,12 +9435,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_72] = [__v_62];
+            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
@@ -10010,12 +9453,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_72] = [__v_62];
+            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
@@ -10028,12 +9471,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_72] = [__v_62];
+            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
@@ -10046,12 +9489,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_72] = [__v_62];
+            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
@@ -10064,12 +9507,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_72] = [__v_62];
+            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
@@ -10082,12 +9525,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_72] = [__v_62];
+            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           7u64 => {
@@ -10100,12 +9543,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_72] = [__v_62];
+            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -10117,15 +9560,15 @@ fn aiur_fn_69(
   })
 }
 
-const INPUT_SIZE_70: usize = 1;
-const IN_70: usize = 1;
-const OUT_70: usize = 2;
-fn aiur_fn_70(
-  inp: [G; IN_70],
+const INPUT_SIZE_73: usize = 1;
+const IN_73: usize = 1;
+const OUT_73: usize = 2;
+fn aiur_fn_73(
+  inp: [G; IN_73],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_70], ExecError> {
+) -> Result<[G; OUT_73], 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 };
@@ -10134,8 +9577,8 @@ fn aiur_fn_70(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_70] = [__v_2, __v_3];
-        record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_73] = [__v_2, __v_3];
+        record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -10143,8 +9586,8 @@ fn aiur_fn_70(
         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_70] = [__v_4, __v_7];
-        record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_73] = [__v_4, __v_7];
+        record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10154,15 +9597,15 @@ fn aiur_fn_70(
   })
 }
 
-const INPUT_SIZE_71: usize = 2;
-const IN_71: usize = 2;
-const OUT_71: usize = 9;
-fn aiur_fn_71(
-  inp: [G; IN_71],
+const INPUT_SIZE_74: usize = 2;
+const IN_74: usize = 2;
+const OUT_74: usize = 9;
+fn aiur_fn_74(
+  inp: [G; IN_74],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_71], ExecError> {
+) -> Result<[G; OUT_74], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10176,17 +9619,17 @@ fn aiur_fn_71(
         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_71] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0];
-        record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_74] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0];
+        record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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_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_71] = { let __args: [G; IN_71] = [__v_3, __v_5]; 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 __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = __r_arr[2];
@@ -10196,26 +9639,26 @@ fn aiur_fn_71(
         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_71] = [__v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14];
-        record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_74] = [__v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14];
+        record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_72: usize = 1;
-const IN_72: usize = 1;
-const OUT_72: usize = 9;
-fn aiur_fn_72(
-  inp: [G; IN_72],
+const INPUT_SIZE_75: usize = 1;
+const IN_75: usize = 1;
+const OUT_75: usize = 9;
+fn aiur_fn_75(
+  inp: [G; IN_75],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_72], ExecError> {
+) -> Result<[G; OUT_75], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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 __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) };
@@ -10254,14 +9697,14 @@ fn aiur_fn_72(
         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_72] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_2];
-        record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_2];
+        record.function_queries[75].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_71] = { let __args: [G; IN_71] = [__v_2, __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 __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2, __v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -10271,26 +9714,26 @@ fn aiur_fn_72(
         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_72] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39];
-        record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39];
+        record.function_queries[75].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 = 10;
-fn aiur_fn_73(
-  inp: [G; IN_73],
+const INPUT_SIZE_76: usize = 1;
+const IN_76: usize = 1;
+const OUT_76: usize = 10;
+fn aiur_fn_76(
+  inp: [G; IN_76],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_73], ExecError> {
+) -> Result<[G; OUT_76], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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 __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) };
@@ -10326,14 +9769,14 @@ fn aiur_fn_73(
         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_73] = [__v_13, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2];
-        record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_76] = [__v_13, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2];
+        record.function_queries[76].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_71] = { let __args: [G; IN_71] = [__v_2, __v_27]; 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 __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2, __v_27]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -10343,26 +9786,26 @@ fn aiur_fn_73(
         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_73] = [__v_13, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
-        record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_76] = [__v_13, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+        record.function_queries[76].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],
+const INPUT_SIZE_77: usize = 1;
+const IN_77: usize = 1;
+const OUT_77: usize = 10;
+fn aiur_fn_77(
+  inp: [G; IN_77],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_74], ExecError> {
+) -> Result<[G; OUT_77], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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 __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) };
@@ -10398,14 +9841,14 @@ fn aiur_fn_74(
         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_19, __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));
+        let __ret: [G; OUT_77] = [__v_19, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2];
+        record.function_queries[77].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_71] = { let __args: [G; IN_71] = [__v_2, __v_27]; 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 __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2, __v_27]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -10415,23 +9858,23 @@ fn aiur_fn_74(
         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_19, __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));
+        let __ret: [G; OUT_77] = [__v_19, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_75: usize = 9;
-const IN_75: usize = 9;
-const OUT_75: usize = 2;
-fn aiur_fn_75(
-  inp: [G; IN_75],
+const INPUT_SIZE_78: usize = 9;
+const IN_78: usize = 9;
+const OUT_78: usize = 2;
+fn aiur_fn_78(
+  inp: [G; IN_78],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_75], ExecError> {
+) -> 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];
@@ -10449,12 +9892,12 @@ fn aiur_fn_75(
         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_75] = [__v_12, __v_0];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_78] = [__v_12, __v_0];
+        record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -10464,7 +9907,7 @@ fn aiur_fn_75(
         let __v_16: G = __r_arr[6];
         let __v_17: G = __r_arr[7];
         let __v_18: G = __r_arr[8];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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];
@@ -10473,13 +9916,13 @@ fn aiur_fn_75(
         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_75] = { let __args: [G; IN_75] = [__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[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 __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !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_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_75] = [__v_30, __v_28];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_78] = [__v_30, __v_28];
+        record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10489,15 +9932,15 @@ fn aiur_fn_75(
   })
 }
 
-const INPUT_SIZE_76: usize = 10;
-const IN_76: usize = 10;
-const OUT_76: usize = 19;
-fn aiur_fn_76(
-  inp: [G; IN_76],
+const INPUT_SIZE_79: usize = 10;
+const IN_79: usize = 10;
+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_76], ExecError> {
+) -> Result<[G; OUT_79], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10532,12 +9975,12 @@ fn aiur_fn_76(
         let __v_26: G = __loaded[15];
         let __v_27: G = __loaded[16];
         let __v_28: G = __loaded[17];
-        let __ret: [G; OUT_76] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_79] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_1]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10561,7 +10004,7 @@ fn aiur_fn_76(
         let __v_31: G = { let __values: [G; 18] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_32: G = G::from_u64(0);
         let __v_33: G = { let __values: [G; 18] = [__v_30, __v_0, __v_31, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
         let __v_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -10570,7 +10013,7 @@ fn aiur_fn_76(
         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_76] = { let __args: [G; IN_76] = [__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[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 __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__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[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_42: G = __r_arr[0];
         let __v_43: G = __r_arr[1];
         let __v_44: G = __r_arr[2];
@@ -10590,8 +10033,8 @@ fn aiur_fn_76(
         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_76] = [__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[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_79] = [__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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10601,15 +10044,15 @@ fn aiur_fn_76(
   })
 }
 
-const INPUT_SIZE_77: usize = 9;
-const IN_77: usize = 9;
-const OUT_77: usize = 19;
-fn aiur_fn_77(
-  inp: [G; IN_77],
+const INPUT_SIZE_80: usize = 9;
+const IN_80: usize = 9;
+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_77], ExecError> {
+) -> Result<[G; OUT_80], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10624,7 +10067,7 @@ fn aiur_fn_77(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -10644,12 +10087,12 @@ fn aiur_fn_77(
         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_77] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __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[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_80] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __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[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -10669,7 +10112,7 @@ fn aiur_fn_77(
         let __v_26: G = __r_arr[16];
         let __v_27: G = __r_arr[17];
         let __v_28: G = __r_arr[18];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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_29: G = __r_arr[0];
         let __v_30: G = __r_arr[1];
         let __v_31: G = __r_arr[2];
@@ -10678,7 +10121,7 @@ fn aiur_fn_77(
         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_77] = { let __args: [G; IN_77] = [__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[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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__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[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_37: G = __r_arr[0];
         let __v_38: G = __r_arr[1];
         let __v_39: G = __r_arr[2];
@@ -10702,8 +10145,8 @@ fn aiur_fn_77(
         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_77] = [__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[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_80] = [__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[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10713,15 +10156,15 @@ fn aiur_fn_77(
   })
 }
 
-const INPUT_SIZE_78: usize = 9;
-const IN_78: usize = 9;
-const OUT_78: usize = 19;
-fn aiur_fn_78(
-  inp: [G; IN_78],
+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_78], ExecError> {
+) -> Result<[G; OUT_81], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10736,7 +10179,7 @@ fn aiur_fn_78(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -10756,12 +10199,12 @@ 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 __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));
+        let __ret: [G; OUT_81] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __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[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -10781,7 +10224,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; 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 __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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_29: G = __r_arr[0];
         let __v_30: G = __r_arr[1];
         let __v_31: G = __r_arr[2];
@@ -10790,7 +10233,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; 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 __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__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[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_37: G = __r_arr[0];
         let __v_38: G = __r_arr[1];
         let __v_39: G = __r_arr[2];
@@ -10814,8 +10257,8 @@ fn aiur_fn_78(
         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));
+        let __ret: [G; OUT_81] = [__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[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10825,18 +10268,18 @@ fn aiur_fn_78(
   })
 }
 
-const INPUT_SIZE_79: usize = 1;
-const IN_79: usize = 1;
-const OUT_79: usize = 19;
-fn aiur_fn_79(
-  inp: [G; IN_79],
+const INPUT_SIZE_82: usize = 1;
+const IN_82: usize = 1;
+const OUT_82: usize = 19;
+fn aiur_fn_82(
+  inp: [G; IN_82],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_79], ExecError> {
+) -> Result<[G; OUT_82], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -10851,19 +10294,19 @@ fn aiur_fn_79(
       0u64 => {
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_79] = [__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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__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[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_11: G = G::from_u64(1);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_79] = [__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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__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[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_10]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10873,17 +10316,17 @@ fn aiur_fn_79(
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_19, __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[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 __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } else { aiur_fn_78(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(2);
         let __v_23: G = G::from_u64(0);
-        let __ret: [G; OUT_79] = [__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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__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[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_10]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10893,17 +10336,17 @@ fn aiur_fn_79(
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_19, __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[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 __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } else { aiur_fn_78(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(3);
         let __v_23: G = G::from_u64(0);
-        let __ret: [G; OUT_79] = [__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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__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[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_10]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10913,7 +10356,7 @@ fn aiur_fn_79(
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -10935,26 +10378,26 @@ fn aiur_fn_79(
         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_79] = [__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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__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[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_11: G = G::from_u64(5);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_79] = [__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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__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[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_11: G = G::from_u64(6);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_79] = [__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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__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[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10975,7 +10418,7 @@ fn aiur_fn_79(
         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_76] = { let __args: [G; IN_76] = [__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[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 __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__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[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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -10995,12 +10438,12 @@ fn aiur_fn_79(
         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_79] = [__v_31, __v_32, __v_33, __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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__v_31, __v_32, __v_33, __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[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__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[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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !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];
@@ -11020,12 +10463,12 @@ fn aiur_fn_79(
         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_79] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __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[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       9u64 => {
-        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 __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];
@@ -11045,12 +10488,12 @@ fn aiur_fn_79(
         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_79] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __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[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       10u64 => {
-        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !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];
@@ -11070,15 +10513,15 @@ fn aiur_fn_79(
         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_79] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __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[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       11u64 => {
         let __v_11: G = G::from_u64(11);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_79] = [__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[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__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[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11088,15 +10531,15 @@ fn aiur_fn_79(
   })
 }
 
-const INPUT_SIZE_80: usize = 9;
-const IN_80: usize = 9;
-const OUT_80: usize = 19;
-fn aiur_fn_80(
-  inp: [G; IN_80],
+const INPUT_SIZE_83: usize = 9;
+const IN_83: usize = 9;
+const OUT_83: usize = 19;
+fn aiur_fn_83(
+  inp: [G; IN_83],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_80], ExecError> {
+) -> Result<[G; OUT_83], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11107,7 +10550,7 @@ fn aiur_fn_80(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
     let __v_11: G = __r_arr[2];
@@ -11127,7 +10570,7 @@ fn aiur_fn_80(
     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_79] = { let __args: [G; IN_79] = [__v_27]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_27]; 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_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
     let __v_30: G = __r_arr[2];
@@ -11147,7 +10590,7 @@ fn aiur_fn_80(
     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_79] = { let __args: [G; IN_79] = [__v_46]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_46]; 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_47: G = __r_arr[0];
     let __v_48: G = __r_arr[1];
     let __v_49: G = __r_arr[2];
@@ -11172,21 +10615,21 @@ fn aiur_fn_80(
     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_80] = [__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[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_83] = [__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[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_81: usize = 17;
-const IN_81: usize = 17;
-const OUT_81: usize = 9;
-fn aiur_fn_81(
-  inp: [G; IN_81],
+const INPUT_SIZE_84: usize = 17;
+const IN_84: usize = 17;
+const OUT_84: usize = 9;
+fn aiur_fn_84(
+  inp: [G; IN_84],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_81], ExecError> {
+) -> Result<[G; OUT_84], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11209,12 +10652,12 @@ fn aiur_fn_81(
     let __v_17: G = __r_arr[0];
     match __v_17.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_81] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_84] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -11223,7 +10666,7 @@ fn aiur_fn_81(
         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_81] = { let __args: [G; IN_81] = [__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[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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
@@ -11236,8 +10679,8 @@ fn aiur_fn_81(
         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_81] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
-        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_84] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
+        record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11247,18 +10690,18 @@ fn aiur_fn_81(
   })
 }
 
-const INPUT_SIZE_82: usize = 1;
-const IN_82: usize = 1;
-const OUT_82: usize = 10;
-fn aiur_fn_82(
-  inp: [G; IN_82],
+const INPUT_SIZE_85: usize = 1;
+const IN_85: usize = 1;
+const OUT_85: usize = 10;
+fn aiur_fn_85(
+  inp: [G; IN_85],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_82], ExecError> {
+) -> Result<[G; OUT_85], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_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 __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -11277,12 +10720,12 @@ fn aiur_fn_82(
           1u64 => {
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_82] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10];
-            record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_85] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10];
+            record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             let __v_14: G = __r_arr[2];
@@ -11293,7 +10736,7 @@ fn aiur_fn_82(
             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_81] = { let __args: [G; IN_81] = [__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[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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
             let __v_23: G = __r_arr[1];
             let __v_24: G = __r_arr[2];
@@ -11303,8 +10746,8 @@ fn aiur_fn_82(
             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_82] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21];
-            record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_85] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21];
+            record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -11313,7 +10756,7 @@ fn aiur_fn_82(
         }
       },
       1u64 => {
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -11324,7 +10767,7 @@ fn aiur_fn_82(
         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_82] = { let __args: [G; IN_82] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_20]; 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_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -11339,12 +10782,12 @@ fn aiur_fn_82(
         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_82] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_85] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
+        record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -11355,7 +10798,7 @@ fn aiur_fn_82(
         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_82] = { let __args: [G; IN_82] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_20]; 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_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -11370,14 +10813,14 @@ fn aiur_fn_82(
         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_82] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_85] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
+        record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_11: G = G::from_u64(4);
-        let __ret: [G; OUT_82] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_85] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
+        record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11387,129 +10830,129 @@ fn aiur_fn_82(
   })
 }
 
-const INPUT_SIZE_83: usize = 1;
-const IN_83: usize = 1;
-const OUT_83: usize = 2;
-fn aiur_fn_83(
-  inp: [G; IN_83],
+const INPUT_SIZE_86: usize = 1;
+const IN_86: usize = 1;
+const OUT_86: usize = 2;
+fn aiur_fn_86(
+  inp: [G; IN_86],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_83], ExecError> {
+) -> Result<[G; OUT_86], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_2]; 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 __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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_4]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_4]; 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_6]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_6]; 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_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_8]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_8]; 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_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_10]; 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 __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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_12]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_12]; 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_14]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_14]; 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_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_16]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_16]; 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_17: G = __r_arr[0];
     let __v_18: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_18]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_18]; 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_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_20]; 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 __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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_22]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_22]; 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_23: G = __r_arr[0];
     let __v_24: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_24]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_24]; 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_25: G = __r_arr[0];
     let __v_26: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_26]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_26]; 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_27: G = __r_arr[0];
     let __v_28: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_28]; 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 __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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_30]; 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_31: G = __r_arr[0];
     let __v_32: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_32]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_32]; 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_33: G = __r_arr[0];
     let __v_34: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_34]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_34]; 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_35: G = __r_arr[0];
     let __v_36: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_36]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_36]; 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_37: G = __r_arr[0];
     let __v_38: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_38]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_38]; 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_39: G = __r_arr[0];
     let __v_40: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_40]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_40]; 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_41: G = __r_arr[0];
     let __v_42: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_42]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_42]; 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_43: G = __r_arr[0];
     let __v_44: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_44]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_44]; 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_45: G = __r_arr[0];
     let __v_46: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_46]; 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 __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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_48]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_48]; 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_49: G = __r_arr[0];
     let __v_50: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_50]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_50]; 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_51: G = __r_arr[0];
     let __v_52: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_52]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_52]; 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_53: G = __r_arr[0];
     let __v_54: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_54]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_54]; 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_55: G = __r_arr[0];
     let __v_56: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_56]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_56]; 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_57: G = __r_arr[0];
     let __v_58: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_58]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_58]; 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_59: G = __r_arr[0];
     let __v_60: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_60]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_60]; 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_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_62]; 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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_62]; 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_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_83] = [__v_65, __v_64];
-    record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_86] = [__v_65, __v_64];
+    record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_84: usize = 9;
-const IN_84: usize = 9;
-const OUT_84: usize = 2;
-fn aiur_fn_84(
-  inp: [G; IN_84],
+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_84], ExecError> {
+) -> Result<[G; OUT_87], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11527,12 +10970,12 @@ fn aiur_fn_84(
         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_84] = [__v_12, __v_0];
-        record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_79] = { let __args: [G; IN_79] = [__v_0]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -11552,7 +10995,7 @@ fn aiur_fn_84(
         let __v_26: G = __r_arr[16];
         let __v_27: G = __r_arr[17];
         let __v_28: G = __r_arr[18];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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_29: G = __r_arr[0];
         let __v_30: G = __r_arr[1];
         let __v_31: G = __r_arr[2];
@@ -11561,14 +11004,14 @@ fn aiur_fn_84(
         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_84] = { let __args: [G; IN_84] = [__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[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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__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[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_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_84] = [__v_41, __v_38];
-        record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_87] = [__v_41, __v_38];
+        record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11578,15 +11021,15 @@ fn aiur_fn_84(
   })
 }
 
-const INPUT_SIZE_85: usize = 9;
-const IN_85: usize = 9;
-const OUT_85: usize = 2;
-fn aiur_fn_85(
-  inp: [G; IN_85],
+const INPUT_SIZE_88: usize = 9;
+const IN_88: usize = 9;
+const OUT_88: usize = 2;
+fn aiur_fn_88(
+  inp: [G; IN_88],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_85], ExecError> {
+) -> Result<[G; OUT_88], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11604,12 +11047,12 @@ fn aiur_fn_85(
         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));
+        let __ret: [G; OUT_88] = [__v_12, __v_0];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -11620,7 +11063,7 @@ fn aiur_fn_85(
         let __v_17: G = __r_arr[7];
         let __v_18: G = __r_arr[8];
         let __v_19: G = __r_arr[9];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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];
@@ -11629,14 +11072,14 @@ fn aiur_fn_85(
         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_85] = { let __args: [G; IN_85] = [__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[85].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = G::from_u64(0);
         let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_85] = [__v_32, __v_29];
-        record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_88] = [__v_32, __v_29];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11646,15 +11089,15 @@ fn aiur_fn_85(
   })
 }
 
-const INPUT_SIZE_86: usize = 9;
-const IN_86: usize = 9;
-const OUT_86: usize = 2;
-fn aiur_fn_86(
-  inp: [G; IN_86],
+const INPUT_SIZE_89: usize = 9;
+const IN_89: usize = 9;
+const OUT_89: usize = 2;
+fn aiur_fn_89(
+  inp: [G; IN_89],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_86], ExecError> {
+) -> Result<[G; OUT_89], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11672,15 +11115,15 @@ fn aiur_fn_86(
         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));
+        let __ret: [G; OUT_89] = [__v_12, __v_0];
+        record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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];
@@ -11689,13 +11132,13 @@ fn aiur_fn_86(
         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_86] = { let __args: [G; IN_86] = [__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[86].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(0);
         let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_86] = [__v_23, __v_21];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_89] = [__v_23, __v_21];
+        record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11705,48 +11148,18 @@ fn aiur_fn_86(
   })
 }
 
-const INPUT_SIZE_87: usize = 1;
-const IN_87: usize = 1;
-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 __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !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_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, __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[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_87] = [__v_10, __v_11];
-    record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_88: usize = 1;
-const IN_88: usize = 1;
-const OUT_88: usize = 2;
-fn aiur_fn_88(
-  inp: [G; IN_88],
+const INPUT_SIZE_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_88], ExecError> {
+) -> Result<[G; OUT_90], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; 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 __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];
@@ -11756,27 +11169,27 @@ 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_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 __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_88] = [__v_10, __v_11];
-    record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_89: usize = 1;
-const IN_89: usize = 1;
-const OUT_89: usize = 2;
-fn aiur_fn_89(
-  inp: [G; IN_89],
+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_89], ExecError> {
+) -> Result<[G; OUT_91], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; 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 __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];
@@ -11786,167 +11199,10 @@ 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_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 __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_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];
-    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_90] = [__v_1, __v_2];
-        record.function_queries[90].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_90] = [__v_1, __v_2];
-        record.function_queries[90].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_90] = [__v_1, __v_2];
-        record.function_queries[90].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_90] = [__v_1, __v_2];
-        record.function_queries[90].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_90] = [__v_1, __v_2];
-        record.function_queries[90].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_90] = [__v_1, __v_2];
-        record.function_queries[90].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_90] = [__v_1, __v_2];
-        record.function_queries[90].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_90] = [__v_1, __v_2];
-        record.function_queries[90].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_90] = [__v_1, __v_2];
-        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_91: usize = 1;
-const IN_91: usize = 1;
-const OUT_91: usize = 13;
-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];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_1]; 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_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2]; 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_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_79] = { let __args: [G; IN_79] = [__v_13]; 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_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_79] = { let __args: [G; IN_79] = [__v_32]; 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_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_91] = [__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];
+    let __ret: [G; OUT_91] = [__v_10, __v_11];
     record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -11954,7 +11210,7 @@ fn aiur_fn_91(
 
 const INPUT_SIZE_92: usize = 1;
 const IN_92: usize = 1;
-const OUT_92: usize = 10;
+const OUT_92: usize = 2;
 fn aiur_fn_92(
   inp: [G; IN_92],
   record: &mut QueryRecord,
@@ -11963,7 +11219,7 @@ 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_72] = { let __args: [G; IN_72] = [__v_0]; 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 __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];
@@ -11973,7 +11229,194 @@ fn aiur_fn_92(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__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 __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __ret: [G; OUT_92] = [__v_10, __v_11];
+    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 = 2;
+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];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(2);
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __v_2: G = G::from_u64(2);
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __v_1: G = G::from_u64(2);
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __v_1: G = G::from_u64(2);
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      10u64 => {
+        let __v_1: G = G::from_u64(2);
+        let __v_2: G = G::from_u64(2);
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_94: usize = 1;
+const IN_94: usize = 1;
+const OUT_94: usize = 13;
+fn aiur_fn_94(
+  inp: [G; IN_94],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_94], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_1]; 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_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_82] = { let __args: [G; IN_82] = [__v_13]; 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_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_82] = { let __args: [G; IN_82] = [__v_32]; 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_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_94] = [__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[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_95: usize = 1;
+const IN_95: usize = 1;
+const OUT_95: usize = 10;
+fn aiur_fn_95(
+  inp: [G; IN_95],
+  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_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -11994,21 +11437,21 @@ fn aiur_fn_92(
     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_92] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29, __v_28];
-    record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_95] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29, __v_28];
+    record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_93: usize = 9;
-const IN_93: usize = 9;
-const OUT_93: usize = 2;
-fn aiur_fn_93(
-  inp: [G; IN_93],
+const INPUT_SIZE_96: usize = 9;
+const IN_96: usize = 9;
+const OUT_96: usize = 2;
+fn aiur_fn_96(
+  inp: [G; IN_96],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_93], ExecError> {
+) -> Result<[G; OUT_96], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12026,12 +11469,12 @@ fn aiur_fn_93(
         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_93] = [__v_12, __v_0];
-        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_96] = [__v_12, __v_0];
+        record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_0]; 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -12042,7 +11485,7 @@ fn aiur_fn_93(
         let __v_17: G = __r_arr[7];
         let __v_18: G = __r_arr[8];
         let __v_19: G = __r_arr[9];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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];
@@ -12051,13 +11494,13 @@ fn aiur_fn_93(
         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_93] = { let __args: [G; IN_93] = [__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[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__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[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_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_93] = [__v_31, __v_29];
-        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_96] = [__v_31, __v_29];
+        record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12067,18 +11510,18 @@ fn aiur_fn_93(
   })
 }
 
-const INPUT_SIZE_94: usize = 1;
-const IN_94: usize = 1;
-const OUT_94: usize = 45;
-fn aiur_fn_94(
-  inp: [G; IN_94],
+const INPUT_SIZE_97: usize = 1;
+const IN_97: usize = 1;
+const OUT_97: usize = 45;
+fn aiur_fn_97(
+  inp: [G; IN_97],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_94], ExecError> {
+) -> Result<[G; OUT_97], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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 __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) };
@@ -12090,7 +11533,7 @@ fn aiur_fn_94(
     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_72] = { let __args: [G; IN_72] = [__v_2]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -12100,7 +11543,7 @@ fn aiur_fn_94(
     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_72] = { let __args: [G; IN_72] = [__v_19]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
     let __v_22: G = __r_arr[2];
@@ -12110,7 +11553,7 @@ fn aiur_fn_94(
     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_72] = { let __args: [G; IN_72] = [__v_28]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
     let __v_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
     let __v_31: G = __r_arr[2];
@@ -12120,7 +11563,7 @@ fn aiur_fn_94(
     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_72] = { let __args: [G; IN_72] = [__v_37]; 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 __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];
@@ -12130,7 +11573,7 @@ fn aiur_fn_94(
     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_72] = { let __args: [G; IN_72] = [__v_46]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_47: G = __r_arr[0];
     let __v_48: G = __r_arr[1];
     let __v_49: G = __r_arr[2];
@@ -12140,7 +11583,7 @@ fn aiur_fn_94(
     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_79] = { let __args: [G; IN_79] = [__v_55]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
     let __v_56: G = __r_arr[0];
     let __v_57: G = __r_arr[1];
     let __v_58: G = __r_arr[2];
@@ -12160,7 +11603,7 @@ fn aiur_fn_94(
     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_72] = { let __args: [G; IN_72] = [__v_74]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_74]; 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_75: G = __r_arr[0];
     let __v_76: G = __r_arr[1];
     let __v_77: G = __r_arr[2];
@@ -12170,31 +11613,31 @@ fn aiur_fn_94(
     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_93] = { let __args: [G; IN_93] = [__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[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__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[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_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_94] = [__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[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_97] = [__v_3, __v_4, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_86, __v_84, __v_85];
+    record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_95: usize = 1;
-const IN_95: usize = 1;
-const OUT_95: usize = 11;
-fn aiur_fn_95(
-  inp: [G; IN_95],
+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_95], ExecError> {
+) -> Result<[G; OUT_98], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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 __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -12204,7 +11647,7 @@ fn aiur_fn_95(
     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_79] = { let __args: [G; IN_79] = [__v_11]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     let __v_14: G = __r_arr[2];
@@ -12225,46 +11668,46 @@ fn aiur_fn_95(
     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_95] = [__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[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_98] = [__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[98].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 = 1;
-fn aiur_fn_96(
-  inp: [G; IN_96],
+const INPUT_SIZE_99: usize = 1;
+const IN_99: usize = 1;
+const OUT_99: usize = 1;
+fn aiur_fn_99(
+  inp: [G; IN_99],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_96], ExecError> {
+) -> Result<[G; OUT_99], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(0);
-        let __ret: [G; OUT_96] = [__v_1];
-        record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_99] = [__v_1];
+        record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_96] = [__v_1];
-        record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_99] = [__v_1];
+        record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_96] = [__v_1];
-        record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_99] = [__v_1];
+        record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_1: G = G::from_u64(3);
-        let __ret: [G; OUT_96] = [__v_1];
-        record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_99] = [__v_1];
+        record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12274,23 +11717,23 @@ fn aiur_fn_96(
   })
 }
 
-const INPUT_SIZE_97: usize = 1;
-const IN_97: usize = 1;
-const OUT_97: usize = 11;
-fn aiur_fn_97(
-  inp: [G; IN_97],
+const INPUT_SIZE_100: usize = 1;
+const IN_100: usize = 1;
+const OUT_100: usize = 11;
+fn aiur_fn_100(
+  inp: [G; IN_100],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_97], ExecError> {
+) -> Result<[G; OUT_100], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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 __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 __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     let __v_6: G = __r_arr[2];
@@ -12300,7 +11743,7 @@ fn aiur_fn_97(
     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_79] = { let __args: [G; IN_79] = [__v_12]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
     let __v_15: G = __r_arr[2];
@@ -12321,27 +11764,27 @@ fn aiur_fn_97(
     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_97] = [__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[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_100] = [__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[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_98: usize = 1;
-const IN_98: usize = 1;
-const OUT_98: usize = 35;
-fn aiur_fn_98(
-  inp: [G; IN_98],
+const INPUT_SIZE_101: usize = 1;
+const IN_101: usize = 1;
+const OUT_101: usize = 35;
+fn aiur_fn_101(
+  inp: [G; IN_101],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_98], ExecError> {
+) -> Result<[G; OUT_101], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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 __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -12351,7 +11794,7 @@ fn aiur_fn_98(
     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_72] = { let __args: [G; IN_72] = [__v_11]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     let __v_14: G = __r_arr[2];
@@ -12361,7 +11804,7 @@ fn aiur_fn_98(
     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_72] = { let __args: [G; IN_72] = [__v_20]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -12371,7 +11814,7 @@ fn aiur_fn_98(
     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_72] = { let __args: [G; IN_72] = [__v_29]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
     let __v_32: G = __r_arr[2];
@@ -12381,7 +11824,7 @@ fn aiur_fn_98(
     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_79] = { let __args: [G; IN_79] = [__v_38]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
     let __v_39: G = __r_arr[0];
     let __v_40: G = __r_arr[1];
     let __v_41: G = __r_arr[2];
@@ -12402,21 +11845,21 @@ fn aiur_fn_98(
     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_98] = [__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[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_101] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __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[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_99: usize = 9;
-const IN_99: usize = 9;
-const OUT_99: usize = 2;
-fn aiur_fn_99(
-  inp: [G; IN_99],
+const INPUT_SIZE_102: usize = 9;
+const IN_102: usize = 9;
+const OUT_102: usize = 2;
+fn aiur_fn_102(
+  inp: [G; IN_102],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_99], ExecError> {
+) -> Result<[G; OUT_102], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12434,12 +11877,12 @@ fn aiur_fn_99(
         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_99] = [__v_12, __v_0];
-        record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_102] = [__v_12, __v_0];
+        record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_0]; 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -12475,7 +11918,7 @@ fn aiur_fn_99(
         let __v_42: G = __r_arr[32];
         let __v_43: G = __r_arr[33];
         let __v_44: G = __r_arr[34];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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];
@@ -12484,13 +11927,13 @@ fn aiur_fn_99(
         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_99] = { let __args: [G; IN_99] = [__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[99].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__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[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_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_99] = [__v_56, __v_54];
-        record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_102] = [__v_56, __v_54];
+        record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12500,18 +11943,18 @@ fn aiur_fn_99(
   })
 }
 
-const INPUT_SIZE_100: usize = 1;
-const IN_100: usize = 1;
-const OUT_100: usize = 28;
-fn aiur_fn_100(
-  inp: [G; IN_100],
+const INPUT_SIZE_103: usize = 1;
+const IN_103: usize = 1;
+const OUT_103: usize = 28;
+fn aiur_fn_103(
+  inp: [G; IN_103],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_100], ExecError> {
+) -> Result<[G; OUT_103], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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 __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) };
@@ -12523,7 +11966,7 @@ fn aiur_fn_100(
     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_72] = { let __args: [G; IN_72] = [__v_2]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -12533,7 +11976,7 @@ fn aiur_fn_100(
     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_72] = { let __args: [G; IN_72] = [__v_19]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
     let __v_22: G = __r_arr[2];
@@ -12543,7 +11986,7 @@ fn aiur_fn_100(
     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_72] = { let __args: [G; IN_72] = [__v_28]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
     let __v_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
     let __v_31: G = __r_arr[2];
@@ -12553,7 +11996,7 @@ fn aiur_fn_100(
     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_79] = { let __args: [G; IN_79] = [__v_37]; 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
     let __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -12573,7 +12016,7 @@ fn aiur_fn_100(
     let __v_54: G = __r_arr[16];
     let __v_55: G = __r_arr[17];
     let __v_56: G = __r_arr[18];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_56]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_57: G = __r_arr[0];
     let __v_58: G = __r_arr[1];
     let __v_59: G = __r_arr[2];
@@ -12583,28 +12026,28 @@ fn aiur_fn_100(
     let __v_63: G = __r_arr[6];
     let __v_64: G = __r_arr[7];
     let __v_65: G = __r_arr[8];
-    let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_66: G = __r_arr[0];
     let __v_67: G = __r_arr[1];
     let __v_68: G = { let __values: [G; 18] = [__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(&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_100] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_68, __v_66, __v_67];
-    record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_103] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_68, __v_66, __v_67];
+    record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_101: usize = 1;
-const IN_101: usize = 1;
-const OUT_101: usize = 10;
-fn aiur_fn_101(
-  inp: [G; IN_101],
+const INPUT_SIZE_104: usize = 1;
+const IN_104: usize = 1;
+const OUT_104: usize = 10;
+fn aiur_fn_104(
+  inp: [G; IN_104],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_101], ExecError> {
+) -> Result<[G; OUT_104], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; 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 __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];
@@ -12614,27 +12057,27 @@ fn aiur_fn_101(
     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_83] = { let __args: [G; IN_83] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_9]; 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_101] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_104] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
+    record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_102: usize = 1;
-const IN_102: usize = 1;
-const OUT_102: usize = 18;
-fn aiur_fn_102(
-  inp: [G; IN_102],
+const INPUT_SIZE_105: usize = 1;
+const IN_105: usize = 1;
+const OUT_105: usize = 18;
+fn aiur_fn_105(
+  inp: [G; IN_105],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_102], ExecError> {
+) -> Result<[G; OUT_105], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; 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 __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];
@@ -12644,7 +12087,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_72] = { let __args: [G; IN_72] = [__v_9]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -12654,32 +12097,32 @@ fn aiur_fn_102(
     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_83] = { let __args: [G; IN_83] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_18]; 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_19: G = __r_arr[0];
     let __v_20: 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, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20];
-    record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_105] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20];
+    record.function_queries[105].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 = 46;
-fn aiur_fn_103(
-  inp: [G; IN_103],
+const INPUT_SIZE_106: usize = 1;
+const IN_106: usize = 1;
+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_103], ExecError> {
+) -> Result<[G; OUT_106], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_2]; 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -12695,12 +12138,12 @@ fn aiur_fn_103(
         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_103] = [__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[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_106] = [__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[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -12731,12 +12174,12 @@ fn aiur_fn_103(
         let __v_30: G = __r_arr[27];
         let __v_31: G = G::from_u64(1);
         let __v_32: G = G::from_u64(0);
-        let __ret: [G; OUT_103] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30];
-        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_106] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30];
+        record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -12783,8 +12226,8 @@ fn aiur_fn_103(
         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_103] = [__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[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_106] = [__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[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12794,15 +12237,15 @@ fn aiur_fn_103(
   })
 }
 
-const INPUT_SIZE_104: usize = 9;
-const IN_104: usize = 9;
-const OUT_104: usize = 2;
-fn aiur_fn_104(
-  inp: [G; IN_104],
+const INPUT_SIZE_107: usize = 9;
+const IN_107: usize = 9;
+const OUT_107: usize = 2;
+fn aiur_fn_107(
+  inp: [G; IN_107],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_104], ExecError> {
+) -> Result<[G; OUT_107], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12820,12 +12263,12 @@ fn aiur_fn_104(
         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_104] = [__v_12, __v_0];
-        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_107] = [__v_12, __v_0];
+        record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !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];
@@ -12872,7 +12315,7 @@ fn aiur_fn_104(
         let __v_53: G = __r_arr[43];
         let __v_54: G = __r_arr[44];
         let __v_55: G = __r_arr[45];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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];
@@ -12881,13 +12324,13 @@ fn aiur_fn_104(
         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_104] = { let __args: [G; IN_104] = [__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[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__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[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_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_104] = [__v_67, __v_65];
-        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_107] = [__v_67, __v_65];
+        record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12897,21 +12340,21 @@ fn aiur_fn_104(
   })
 }
 
-const INPUT_SIZE_105: usize = 2;
-const IN_105: usize = 2;
-const OUT_105: usize = 46;
-fn aiur_fn_105(
-  inp: [G; IN_105],
+const INPUT_SIZE_108: usize = 2;
+const IN_108: usize = 2;
+const OUT_108: usize = 46;
+fn aiur_fn_108(
+  inp: [G; IN_108],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_105], ExecError> {
+) -> Result<[G; OUT_108], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        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 __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12927,12 +12370,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_108] = [__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[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12979,12 +12422,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_108] = [__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[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        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 __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];
@@ -12998,12 +12441,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_108] = [__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[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        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 __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -13017,12 +12460,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_108] = [__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[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        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 __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -13043,12 +12486,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_108] = [__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[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -13061,12 +12504,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_108] = [__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[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -13079,12 +12522,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_108] = [__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[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -13097,8 +12540,8 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_108] = [__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[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -13108,15 +12551,15 @@ fn aiur_fn_105(
   })
 }
 
-const INPUT_SIZE_106: usize = 10;
-const IN_106: usize = 10;
-const OUT_106: usize = 46;
-fn aiur_fn_106(
-  inp: [G; IN_106],
+const INPUT_SIZE_109: usize = 10;
+const IN_109: usize = 10;
+const OUT_109: usize = 46;
+fn aiur_fn_109(
+  inp: [G; IN_109],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_106], ExecError> {
+) -> Result<[G; OUT_109], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13130,17 +12573,17 @@ fn aiur_fn_106(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       12u64 => {
-        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__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[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__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[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_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_106] = [__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[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_109] = [__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[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       13u64 => {
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1, __v_9]; 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -13187,8 +12630,8 @@ fn aiur_fn_106(
         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_106] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_109] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -13198,18 +12641,18 @@ fn aiur_fn_106(
   })
 }
 
-const INPUT_SIZE_107: usize = 1;
-const IN_107: usize = 1;
-const OUT_107: usize = 49;
-fn aiur_fn_107(
-  inp: [G; IN_107],
+const INPUT_SIZE_110: usize = 1;
+const IN_110: usize = 1;
+const OUT_110: usize = 49;
+fn aiur_fn_110(
+  inp: [G; IN_110],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_107], ExecError> {
+) -> Result<[G; OUT_110], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -13220,7 +12663,7 @@ fn aiur_fn_107(
     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_106] = { let __args: [G; IN_106] = [__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[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__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[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];
@@ -13267,30 +12710,30 @@ fn aiur_fn_107(
     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_87] = { let __args: [G; IN_87] = [__v_56]; 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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_56]; 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_57: G = __r_arr[0];
     let __v_58: G = __r_arr[1];
-    let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_58]; 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_59: G = __r_arr[0];
     let __v_60: G = __r_arr[1];
-    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_60]; 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_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
-    let __ret: [G; OUT_107] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_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_57, __v_59, __v_61, __v_62];
+    record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_108: usize = 1;
-const IN_108: usize = 1;
-const OUT_108: usize = 1;
-fn aiur_fn_108(
-  inp: [G; IN_108],
+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_108], ExecError> {
+) -> Result<[G; OUT_111], 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 };
@@ -13308,50 +12751,50 @@ fn aiur_fn_108(
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
         let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_108] = [__v_12];
-        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_111] = [__v_12];
+        record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_108] = [__v_13];
-        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_111] = [__v_13];
+        record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_10: G = G::from_u64(2);
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3]; 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_12: G = __r_arr[0];
         let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_108] = [__v_13];
-        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_111] = [__v_13];
+        record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_10: G = G::from_u64(3);
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3]; 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_12: G = __r_arr[0];
         let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_108] = [__v_13];
-        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_111] = [__v_13];
+        record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_10: G = G::from_u64(4);
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_108] = [__v_13];
-        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_111] = [__v_13];
+        record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -13361,15 +12804,15 @@ fn aiur_fn_108(
   })
 }
 
-const INPUT_SIZE_109: usize = 2;
-const IN_109: usize = 2;
-const OUT_109: usize = 1;
-fn aiur_fn_109(
-  inp: [G; IN_109],
+const INPUT_SIZE_112: usize = 2;
+const IN_112: usize = 2;
+const OUT_112: usize = 1;
+fn aiur_fn_112(
+  inp: [G; IN_112],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_109], ExecError> {
+) -> Result<[G; OUT_112], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13389,23 +12832,23 @@ fn aiur_fn_109(
         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_109] = [__v_14];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_112] = [__v_14];
+        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_13]; 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_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11, __v_1]; 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_16: G = __r_arr[0];
         let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_109] = [__v_17];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_112] = [__v_17];
+        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -13415,15 +12858,15 @@ fn aiur_fn_109(
   })
 }
 
-const INPUT_SIZE_110: usize = 1;
-const IN_110: usize = 1;
-const OUT_110: usize = 1;
-fn aiur_fn_110(
-  inp: [G; IN_110],
+const INPUT_SIZE_113: usize = 1;
+const IN_113: usize = 1;
+const OUT_113: usize = 1;
+fn aiur_fn_113(
+  inp: [G; IN_113],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_110], ExecError> {
+) -> Result<[G; OUT_113], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -13435,7 +12878,7 @@ fn aiur_fn_110(
     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_111] = { let __args: [G; IN_111] = [__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[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__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[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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -13445,7 +12888,7 @@ fn aiur_fn_110(
     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_112] = { let __args: [G; IN_112] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0, __v_18]; 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_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];
@@ -13460,8 +12903,8 @@ fn aiur_fn_110(
             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_110] = [__v_26];
-            record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_113] = [__v_26];
+            record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -13470,8 +12913,8 @@ fn aiur_fn_110(
             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_110] = [__v_28];
-            record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_113] = [__v_28];
+            record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -13480,27 +12923,27 @@ fn aiur_fn_110(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_19]; 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_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_110] = [__v_25];
-        record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_113] = [__v_25];
+        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_111: usize = 10;
-const IN_111: usize = 10;
-const OUT_111: usize = 8;
-fn aiur_fn_111(
-  inp: [G; IN_111],
+const INPUT_SIZE_114: usize = 10;
+const IN_114: usize = 10;
+const OUT_114: usize = 8;
+fn aiur_fn_114(
+  inp: [G; IN_114],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_111], ExecError> {
+) -> Result<[G; OUT_114], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13514,8 +12957,8 @@ fn aiur_fn_111(
     let __v_9: G = inp[9];
     match __v_9.as_canonical_u64() {
       8u64 => {
-        let __ret: [G; OUT_111] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_114] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -13525,15 +12968,15 @@ fn aiur_fn_111(
         let __v_12: G = __loaded[2];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_111] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-            record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_114] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+            record.function_queries[114].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_111] = { let __args: [G; IN_111] = [__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[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__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[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13542,13 +12985,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_114] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_13: G = G::from_u64(2);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__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[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13557,13 +13000,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_114] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               2u64 => {
                 let __v_13: G = G::from_u64(3);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__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[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13572,13 +13015,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_114] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               3u64 => {
                 let __v_13: G = G::from_u64(4);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__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[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13587,13 +13030,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_114] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               4u64 => {
                 let __v_13: G = G::from_u64(5);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__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[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13602,13 +13045,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_114] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               5u64 => {
                 let __v_13: G = G::from_u64(6);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__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[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13617,13 +13060,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_114] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               6u64 => {
                 let __v_13: G = G::from_u64(7);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__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[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13632,13 +13075,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_114] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(8);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__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[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13647,8 +13090,8 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_114] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -13662,22 +13105,22 @@ fn aiur_fn_111(
   })
 }
 
-const INPUT_SIZE_112: usize = 2;
-const IN_112: usize = 2;
-const OUT_112: usize = 1;
-fn aiur_fn_112(
-  inp: [G; IN_112],
+const INPUT_SIZE_115: usize = 2;
+const IN_115: usize = 2;
+const OUT_115: usize = 1;
+fn aiur_fn_115(
+  inp: [G; IN_115],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_112], ExecError> {
+) -> Result<[G; OUT_115], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_112] = [__v_0];
-        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_115] = [__v_0];
+        record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -13690,17 +13133,17 @@ fn aiur_fn_112(
             let __v_5: G = G::from_u64(1);
             let __v_6: G = G::from_u64(1);
             let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_112] = [__v_7];
-            record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_115] = [__v_7];
+            record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_112] = [__v_7];
-            record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_115] = [__v_7];
+            record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -13712,15 +13155,15 @@ fn aiur_fn_112(
   })
 }
 
-const INPUT_SIZE_113: usize = 6;
-const IN_113: usize = 6;
-const OUT_113: usize = 1;
-fn aiur_fn_113(
-  inp: [G; IN_113],
+const INPUT_SIZE_116: usize = 6;
+const IN_116: usize = 6;
+const OUT_116: usize = 1;
+fn aiur_fn_116(
+  inp: [G; IN_116],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_113], ExecError> {
+) -> Result<[G; OUT_116], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13749,149 +13192,149 @@ fn aiur_fn_113(
     let __v_23: G = __loaded[17];
     match __v_6.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_5, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_5, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(1);
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_25]; 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_27: G = __r_arr[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_113] = [__v_29];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_116] = [__v_29];
+        record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_24: G = G::from_u64(0);
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_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_113] = [__v_27];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_116] = [__v_27];
+        record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
         let __v_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_113] = [__v_29];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_116] = [__v_29];
+        record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
         let __v_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_113] = [__v_29];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_116] = [__v_29];
+        record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(8);
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_23, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_23, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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_113] = [__v_29];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_116] = [__v_29];
+        record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__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[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
         let __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_113] = [__v_28];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_116] = [__v_28];
+        record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__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[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__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[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_24]; 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_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_113] = [__v_29];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_116] = [__v_29];
+        record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_24: G = G::from_u64(3);
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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_113] = [__v_28];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_116] = [__v_28];
+        record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_24: G = G::from_u64(4);
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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_113] = [__v_28];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_116] = [__v_28];
+        record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       9u64 => {
         let __v_24: G = G::from_u64(5);
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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_113] = [__v_28];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_116] = [__v_28];
+        record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       10u64 => {
         let __v_24: G = G::from_u64(6);
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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_113] = [__v_28];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_116] = [__v_28];
+        record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       11u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_1, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_1, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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];
@@ -13899,10 +13342,10 @@ fn aiur_fn_113(
         let __v_28: G = __loaded[2];
         match __v_26.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_29: G = __r_arr[0];
-            let __ret: [G; OUT_113] = [__v_29];
-            record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_116] = [__v_29];
+            record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -13917,15 +13360,15 @@ fn aiur_fn_113(
   })
 }
 
-const INPUT_SIZE_114: usize = 7;
-const IN_114: usize = 7;
-const OUT_114: usize = 1;
-fn aiur_fn_114(
-  inp: [G; IN_114],
+const INPUT_SIZE_117: usize = 7;
+const IN_117: usize = 7;
+const OUT_117: usize = 1;
+fn aiur_fn_117(
+  inp: [G; IN_117],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_114], ExecError> {
+) -> Result<[G; OUT_117], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13951,8 +13394,8 @@ fn aiur_fn_114(
         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_114] = [__v_20];
-        record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_117] = [__v_20];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -13966,16 +13409,16 @@ fn aiur_fn_114(
               0u64 => {
                 match __v_2.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_16, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_16, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_21: G = __r_arr[0];
-                    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                     let __v_22: G = __r_arr[0];
                     let __v_23: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_17, __v_20, __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 __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_17, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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_114] = [__v_25];
-                    record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_117] = [__v_25];
+                    record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -13994,15 +13437,15 @@ fn aiur_fn_114(
   })
 }
 
-const INPUT_SIZE_115: usize = 18;
-const IN_115: usize = 18;
-const OUT_115: usize = 11;
-fn aiur_fn_115(
-  inp: [G; IN_115],
+const INPUT_SIZE_118: usize = 18;
+const IN_118: usize = 18;
+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_115], ExecError> {
+) -> Result<[G; OUT_118], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14026,51 +13469,51 @@ fn aiur_fn_115(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10, __v_12, __v_13, __v_14, __v_15, __v_16]; 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_18: G = __r_arr[0];
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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_19: G = __r_arr[0];
             match __v_0.as_canonical_u64() {
               0u64 => {
                 let __v_20: G = G::from_u64(1);
-                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                 let __v_21: G = __r_arr[0];
                 let __v_22: G = G::from_u64(0);
-                let __ret: [G; OUT_115] = [__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[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_118] = [__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[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
                 match __v_1.as_canonical_u64() {
                   0u64 => {
                     let __v_20: G = G::from_u64(3);
-                    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                     let __v_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_115] = [__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[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_118] = [__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[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_20: G = G::from_u64(3);
-                    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                     let __v_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_115] = [__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[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_118] = [__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[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               2u64 => {
                 let __v_20: G = G::from_u64(2);
-                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                 let __v_21: G = __r_arr[0];
                 let __v_22: G = G::from_u64(0);
-                let __ret: [G; OUT_115] = [__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[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_118] = [__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[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -14084,15 +13527,15 @@ fn aiur_fn_115(
   })
 }
 
-const INPUT_SIZE_116: usize = 15;
-const IN_116: usize = 15;
-const OUT_116: usize = 11;
-fn aiur_fn_116(
-  inp: [G; IN_116],
+const INPUT_SIZE_119: usize = 15;
+const IN_119: usize = 15;
+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_116], ExecError> {
+) -> Result<[G; OUT_119], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14113,14 +13556,14 @@ fn aiur_fn_116(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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_15: G = __r_arr[0];
             let __v_16: G = G::from_u64(0);
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __v_18: G = G::from_u64(0);
-            let __ret: [G; OUT_116] = [__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[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_119] = [__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[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -14129,15 +13572,15 @@ fn aiur_fn_116(
   })
 }
 
-const INPUT_SIZE_117: usize = 15;
-const IN_117: usize = 15;
-const OUT_117: usize = 11;
-fn aiur_fn_117(
-  inp: [G; IN_117],
+const INPUT_SIZE_120: usize = 15;
+const IN_120: usize = 15;
+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_117], ExecError> {
+) -> Result<[G; OUT_120], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14158,14 +13601,14 @@ fn aiur_fn_117(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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_15: G = __r_arr[0];
             let __v_16: G = G::from_u64(4);
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_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));
+            let __ret: [G; OUT_120] = [__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[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -14174,15 +13617,15 @@ fn aiur_fn_117(
   })
 }
 
-const INPUT_SIZE_118: usize = 51;
-const IN_118: usize = 51;
-const OUT_118: usize = 11;
-fn aiur_fn_118(
-  inp: [G; IN_118],
+const INPUT_SIZE_121: usize = 51;
+const IN_121: usize = 51;
+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_118], ExecError> {
+) -> Result<[G; OUT_121], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14239,23 +13682,23 @@ fn aiur_fn_118(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_42, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_42, __v_44, __v_45, __v_46, __v_47, __v_48]; 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_51: G = __r_arr[0];
-            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_43, __v_49, __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 __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_43, __v_49, __v_44, __v_45, __v_46, __v_47, __v_48]; 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_52: G = __r_arr[0];
             let __v_53: G = G::from_u64(7);
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_54: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_55: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_56: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_57: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_58: G = __r_arr[0];
-            let __ret: [G; OUT_118] = [__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[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -14264,15 +13707,15 @@ fn aiur_fn_118(
   })
 }
 
-const INPUT_SIZE_119: usize = 34;
-const IN_119: usize = 34;
-const OUT_119: usize = 11;
-fn aiur_fn_119(
-  inp: [G; IN_119],
+const INPUT_SIZE_122: usize = 34;
+const IN_122: usize = 34;
+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_119], ExecError> {
+) -> Result<[G; OUT_122], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14312,18 +13755,18 @@ fn aiur_fn_119(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_25, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_25, __v_27, __v_28, __v_29, __v_30, __v_31]; 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_34: G = __r_arr[0];
             let __v_35: G = G::from_u64(5);
-            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 __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_38: G = __r_arr[0];
             let __v_39: G = G::from_u64(0);
-            let __ret: [G; OUT_119] = [__v_35, __v_36, __v_34, __v_37, __v_38, __v_32, __v_0, __v_33, __v_39, __v_39, __v_39];
-            record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_122] = [__v_35, __v_36, __v_34, __v_37, __v_38, __v_32, __v_0, __v_33, __v_39, __v_39, __v_39];
+            record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -14332,15 +13775,15 @@ fn aiur_fn_119(
   })
 }
 
-const INPUT_SIZE_120: usize = 40;
-const IN_120: usize = 40;
-const OUT_120: usize = 11;
-fn aiur_fn_120(
-  inp: [G; IN_120],
+const INPUT_SIZE_123: usize = 40;
+const IN_123: usize = 40;
+const OUT_123: usize = 11;
+fn aiur_fn_123(
+  inp: [G; IN_123],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_120], ExecError> {
+) -> Result<[G; OUT_123], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14386,20 +13829,20 @@ fn aiur_fn_120(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !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_40: G = __r_arr[0];
             let __v_41: G = G::from_u64(6);
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_42: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_43: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_44: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_45: G = __r_arr[0];
             let __v_46: G = G::from_u64(0);
-            let __ret: [G; OUT_120] = [__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[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_123] = [__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[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -14408,15 +13851,15 @@ fn aiur_fn_120(
   })
 }
 
-const INPUT_SIZE_121: usize = 1;
-const IN_121: usize = 1;
-const OUT_121: usize = 11;
-fn aiur_fn_121(
-  inp: [G; IN_121],
+const INPUT_SIZE_124: usize = 1;
+const IN_124: usize = 1;
+const OUT_124: usize = 11;
+fn aiur_fn_124(
+  inp: [G; IN_124],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_121], ExecError> {
+) -> Result<[G; OUT_124], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -14476,7 +13919,7 @@ fn aiur_fn_121(
       _ => {
         match __v_6.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_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[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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_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[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];
@@ -14488,12 +13931,12 @@ fn aiur_fn_121(
             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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_124] = [__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[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            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_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
             let __v_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
             let __v_55: G = __r_arr[2];
@@ -14505,12 +13948,12 @@ fn aiur_fn_121(
             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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_124] = [__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[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            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 __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_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
             let __v_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
             let __v_55: G = __r_arr[2];
@@ -14522,12 +13965,12 @@ fn aiur_fn_121(
             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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_124] = [__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[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            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_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[118].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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_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[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];
@@ -14539,12 +13982,12 @@ fn aiur_fn_121(
             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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_124] = [__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[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            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_1, __v_2, __v_3, __v_4, __v_5, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_1, __v_2, __v_3, __v_4, __v_5, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
             let __v_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
             let __v_55: G = __r_arr[2];
@@ -14556,12 +13999,12 @@ fn aiur_fn_121(
             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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_124] = [__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[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
-            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_1, __v_2, __v_3, __v_4, __v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_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[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_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
             let __v_55: G = __r_arr[2];
@@ -14573,8 +14016,8 @@ fn aiur_fn_121(
             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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_124] = [__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[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -14586,15 +14029,15 @@ fn aiur_fn_121(
   })
 }
 
-const INPUT_SIZE_122: usize = 1;
-const IN_122: usize = 1;
-const OUT_122: usize = 1;
-fn aiur_fn_122(
-  inp: [G; IN_122],
+const INPUT_SIZE_125: usize = 1;
+const IN_125: usize = 1;
+const OUT_125: usize = 1;
+fn aiur_fn_125(
+  inp: [G; IN_125],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_122], ExecError> {
+) -> Result<[G; OUT_125], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -14606,12 +14049,12 @@ fn aiur_fn_122(
         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_122] = [__v_6];
-        record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_125] = [__v_6];
+        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_2]; 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_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         let __v_6: G = __r_arr[2];
@@ -14625,11 +14068,11 @@ fn aiur_fn_122(
         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_122] = { let __args: [G; IN_122] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
         let __v_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_122] = [__v_18];
-        record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_125] = [__v_18];
+        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -14639,15 +14082,15 @@ fn aiur_fn_122(
   })
 }
 
-const INPUT_SIZE_123: usize = 1;
-const IN_123: usize = 1;
-const OUT_123: usize = 48;
-fn aiur_fn_123(
-  inp: [G; IN_123],
+const INPUT_SIZE_126: usize = 1;
+const IN_126: usize = 1;
+const OUT_126: usize = 48;
+fn aiur_fn_126(
+  inp: [G; IN_126],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_123], ExecError> {
+) -> Result<[G; OUT_126], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -14690,8 +14133,8 @@ fn aiur_fn_123(
     let __v_36: G = G::from_u64(2);
     let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_37]; 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_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -14756,21 +14199,21 @@ fn aiur_fn_123(
     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_123] = [__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[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_126] = [__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[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_124: usize = 1;
-const IN_124: usize = 1;
-const OUT_124: usize = 1;
-fn aiur_fn_124(
-  inp: [G; IN_124],
+const INPUT_SIZE_127: usize = 1;
+const IN_127: usize = 1;
+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_124], ExecError> {
+) -> Result<[G; OUT_127], 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 };
@@ -14813,22 +14256,22 @@ fn aiur_fn_124(
     let __v_36: G = G::from_u64(5);
     let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __ret: [G; OUT_124] = [__v_37];
-    record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_127] = [__v_37];
+    record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_125: usize = 2;
-const IN_125: usize = 2;
-const OUT_125: usize = 1;
-fn aiur_fn_125(
-  inp: [G; IN_125],
+const INPUT_SIZE_128: usize = 2;
+const IN_128: usize = 2;
+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_125], ExecError> {
+) -> Result<[G; OUT_128], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14992,269 +14435,269 @@ fn aiur_fn_125(
                                                                                                                             match __v_96.as_canonical_u64() {
                                                                                                                               0u64 => {
                                                                                                                                 let __v_97: G = G::from_u64(1);
-                                                                                                                                let __ret: [G; OUT_125] = [__v_97];
-                                                                                                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                let __ret: [G; OUT_128] = [__v_97];
+                                                                                                                                record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                                 return Ok(__ret);
                                                                                                                               },
                                                                                                                               _ => {
                                                                                                                                 let __v_97: G = G::from_u64(0);
-                                                                                                                                let __ret: [G; OUT_125] = [__v_97];
-                                                                                                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                let __ret: [G; OUT_128] = [__v_97];
+                                                                                                                                record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                                 return Ok(__ret);
                                                                                                                               },
                                                                                                                             }
                                                                                                                           },
                                                                                                                           _ => {
                                                                                                                             let __v_97: G = G::from_u64(0);
-                                                                                                                            let __ret: [G; OUT_125] = [__v_97];
-                                                                                                                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                            let __ret: [G; OUT_128] = [__v_97];
+                                                                                                                            record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                             return Ok(__ret);
                                                                                                                           },
                                                                                                                         }
                                                                                                                       },
                                                                                                                       _ => {
                                                                                                                         let __v_97: G = G::from_u64(0);
-                                                                                                                        let __ret: [G; OUT_125] = [__v_97];
-                                                                                                                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                        let __ret: [G; OUT_128] = [__v_97];
+                                                                                                                        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                         return Ok(__ret);
                                                                                                                       },
                                                                                                                     }
                                                                                                                   },
                                                                                                                   _ => {
                                                                                                                     let __v_97: G = G::from_u64(0);
-                                                                                                                    let __ret: [G; OUT_125] = [__v_97];
-                                                                                                                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                    let __ret: [G; OUT_128] = [__v_97];
+                                                                                                                    record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                     return Ok(__ret);
                                                                                                                   },
                                                                                                                 }
                                                                                                               },
                                                                                                               _ => {
                                                                                                                 let __v_97: G = G::from_u64(0);
-                                                                                                                let __ret: [G; OUT_125] = [__v_97];
-                                                                                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                let __ret: [G; OUT_128] = [__v_97];
+                                                                                                                record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                 return Ok(__ret);
                                                                                                               },
                                                                                                             }
                                                                                                           },
                                                                                                           _ => {
                                                                                                             let __v_97: G = G::from_u64(0);
-                                                                                                            let __ret: [G; OUT_125] = [__v_97];
-                                                                                                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                            let __ret: [G; OUT_128] = [__v_97];
+                                                                                                            record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                             return Ok(__ret);
                                                                                                           },
                                                                                                         }
                                                                                                       },
                                                                                                       _ => {
                                                                                                         let __v_97: G = G::from_u64(0);
-                                                                                                        let __ret: [G; OUT_125] = [__v_97];
-                                                                                                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                        let __ret: [G; OUT_128] = [__v_97];
+                                                                                                        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                         return Ok(__ret);
                                                                                                       },
                                                                                                     }
                                                                                                   },
                                                                                                   _ => {
                                                                                                     let __v_97: G = G::from_u64(0);
-                                                                                                    let __ret: [G; OUT_125] = [__v_97];
-                                                                                                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                    let __ret: [G; OUT_128] = [__v_97];
+                                                                                                    record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                     return Ok(__ret);
                                                                                                   },
                                                                                                 }
                                                                                               },
                                                                                               _ => {
                                                                                                 let __v_97: G = G::from_u64(0);
-                                                                                                let __ret: [G; OUT_125] = [__v_97];
-                                                                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                let __ret: [G; OUT_128] = [__v_97];
+                                                                                                record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                 return Ok(__ret);
                                                                                               },
                                                                                             }
                                                                                           },
                                                                                           _ => {
                                                                                             let __v_97: G = G::from_u64(0);
-                                                                                            let __ret: [G; OUT_125] = [__v_97];
-                                                                                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                            let __ret: [G; OUT_128] = [__v_97];
+                                                                                            record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                             return Ok(__ret);
                                                                                           },
                                                                                         }
                                                                                       },
                                                                                       _ => {
                                                                                         let __v_97: G = G::from_u64(0);
-                                                                                        let __ret: [G; OUT_125] = [__v_97];
-                                                                                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                        let __ret: [G; OUT_128] = [__v_97];
+                                                                                        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                         return Ok(__ret);
                                                                                       },
                                                                                     }
                                                                                   },
                                                                                   _ => {
                                                                                     let __v_97: G = G::from_u64(0);
-                                                                                    let __ret: [G; OUT_125] = [__v_97];
-                                                                                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                    let __ret: [G; OUT_128] = [__v_97];
+                                                                                    record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                     return Ok(__ret);
                                                                                   },
                                                                                 }
                                                                               },
                                                                               _ => {
                                                                                 let __v_97: G = G::from_u64(0);
-                                                                                let __ret: [G; OUT_125] = [__v_97];
-                                                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                let __ret: [G; OUT_128] = [__v_97];
+                                                                                record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                 return Ok(__ret);
                                                                               },
                                                                             }
                                                                           },
                                                                           _ => {
                                                                             let __v_97: G = G::from_u64(0);
-                                                                            let __ret: [G; OUT_125] = [__v_97];
-                                                                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                            let __ret: [G; OUT_128] = [__v_97];
+                                                                            record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                             return Ok(__ret);
                                                                           },
                                                                         }
                                                                       },
                                                                       _ => {
                                                                         let __v_97: G = G::from_u64(0);
-                                                                        let __ret: [G; OUT_125] = [__v_97];
-                                                                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                        let __ret: [G; OUT_128] = [__v_97];
+                                                                        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                         return Ok(__ret);
                                                                       },
                                                                     }
                                                                   },
                                                                   _ => {
                                                                     let __v_97: G = G::from_u64(0);
-                                                                    let __ret: [G; OUT_125] = [__v_97];
-                                                                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                    let __ret: [G; OUT_128] = [__v_97];
+                                                                    record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                     return Ok(__ret);
                                                                   },
                                                                 }
                                                               },
                                                               _ => {
                                                                 let __v_97: G = G::from_u64(0);
-                                                                let __ret: [G; OUT_125] = [__v_97];
-                                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                let __ret: [G; OUT_128] = [__v_97];
+                                                                record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                 return Ok(__ret);
                                                               },
                                                             }
                                                           },
                                                           _ => {
                                                             let __v_97: G = G::from_u64(0);
-                                                            let __ret: [G; OUT_125] = [__v_97];
-                                                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            let __ret: [G; OUT_128] = [__v_97];
+                                                            record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                             return Ok(__ret);
                                                           },
                                                         }
                                                       },
                                                       _ => {
                                                         let __v_97: G = G::from_u64(0);
-                                                        let __ret: [G; OUT_125] = [__v_97];
-                                                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                        let __ret: [G; OUT_128] = [__v_97];
+                                                        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                         return Ok(__ret);
                                                       },
                                                     }
                                                   },
                                                   _ => {
                                                     let __v_97: G = G::from_u64(0);
-                                                    let __ret: [G; OUT_125] = [__v_97];
-                                                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_128] = [__v_97];
+                                                    record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                 }
                                               },
                                               _ => {
                                                 let __v_97: G = G::from_u64(0);
-                                                let __ret: [G; OUT_125] = [__v_97];
-                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_128] = [__v_97];
+                                                record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
                                           },
                                           _ => {
                                             let __v_97: G = G::from_u64(0);
-                                            let __ret: [G; OUT_125] = [__v_97];
-                                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_128] = [__v_97];
+                                            record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
                                       },
                                       _ => {
                                         let __v_97: G = G::from_u64(0);
-                                        let __ret: [G; OUT_125] = [__v_97];
-                                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_128] = [__v_97];
+                                        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
                                   },
                                   _ => {
                                     let __v_97: G = G::from_u64(0);
-                                    let __ret: [G; OUT_125] = [__v_97];
-                                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_128] = [__v_97];
+                                    record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
                                 let __v_97: G = G::from_u64(0);
-                                let __ret: [G; OUT_125] = [__v_97];
-                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_128] = [__v_97];
+                                record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_97: G = G::from_u64(0);
-                            let __ret: [G; OUT_125] = [__v_97];
-                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_128] = [__v_97];
+                            record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_97: G = G::from_u64(0);
-                        let __ret: [G; OUT_125] = [__v_97];
-                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_128] = [__v_97];
+                        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_97: G = G::from_u64(0);
-                    let __ret: [G; OUT_125] = [__v_97];
-                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_128] = [__v_97];
+                    record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_97: G = G::from_u64(0);
-                let __ret: [G; OUT_125] = [__v_97];
-                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_128] = [__v_97];
+                record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_97: G = G::from_u64(0);
-            let __ret: [G; OUT_125] = [__v_97];
-            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_128] = [__v_97];
+            record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_97: G = G::from_u64(0);
-        let __ret: [G; OUT_125] = [__v_97];
-        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_128] = [__v_97];
+        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_126: usize = 2;
-const IN_126: usize = 2;
-const OUT_126: usize = 1;
-fn aiur_fn_126(
-  inp: [G; IN_126],
+const INPUT_SIZE_129: usize = 2;
+const IN_129: usize = 2;
+const OUT_129: usize = 1;
+fn aiur_fn_129(
+  inp: [G; IN_129],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_126], ExecError> {
+) -> Result<[G; OUT_129], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15327,31 +14770,31 @@ fn aiur_fn_126(
     let __v_66: G = (__v_2 - __v_34);
     match __v_66.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
         let __v_67: G = __r_arr[0];
-        let __ret: [G; OUT_126] = [__v_67];
-        record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_129] = [__v_67];
+        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_67: G = G::from_u64(0);
-        let __ret: [G; OUT_126] = [__v_67];
-        record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_129] = [__v_67];
+        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_127: usize = 1;
-const IN_127: usize = 1;
-const OUT_127: usize = 1;
-fn aiur_fn_127(
-  inp: [G; IN_127],
+const INPUT_SIZE_130: usize = 1;
+const IN_130: usize = 1;
+const OUT_130: usize = 1;
+fn aiur_fn_130(
+  inp: [G; IN_130],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_127], ExecError> {
+) -> Result<[G; OUT_130], 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 };
@@ -15400,8 +14843,8 @@ fn aiur_fn_127(
     let __v_40: G = __loaded[2];
     match __v_38.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_127] = [__v_39];
-        record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_130] = [__v_39];
+        record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15411,32 +14854,32 @@ fn aiur_fn_127(
   })
 }
 
-const INPUT_SIZE_128: usize = 0;
-const IN_128: usize = 0;
-const OUT_128: usize = 1;
-fn aiur_fn_128(
-  inp: [G; IN_128],
+const INPUT_SIZE_131: usize = 0;
+const IN_131: usize = 0;
+const OUT_131: usize = 1;
+fn aiur_fn_131(
+  inp: [G; IN_131],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_128], ExecError> {
+) -> Result<[G; OUT_131], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(4294967295);
-    let __ret: [G; OUT_128] = [__v_0];
-    record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_131] = [__v_0];
+    record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_129: usize = 45;
-const IN_129: usize = 45;
-const OUT_129: usize = 1;
-fn aiur_fn_129(
-  inp: [G; IN_129],
+const INPUT_SIZE_132: usize = 45;
+const IN_132: usize = 45;
+const OUT_132: usize = 1;
+fn aiur_fn_132(
+  inp: [G; IN_132],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_129], ExecError> {
+) -> Result<[G; OUT_132], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15487,8 +14930,8 @@ fn aiur_fn_129(
       6u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __ret: [G; OUT_129] = [__v_9];
-            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_132] = [__v_9];
+            record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -15496,8 +14939,8 @@ fn aiur_fn_129(
       4u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __ret: [G; OUT_129] = [__v_17];
-            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_132] = [__v_17];
+            record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -15505,8 +14948,8 @@ fn aiur_fn_129(
       5u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __ret: [G; OUT_129] = [__v_9];
-            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_132] = [__v_9];
+            record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -15514,8 +14957,8 @@ fn aiur_fn_129(
       7u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __ret: [G; OUT_129] = [__v_9];
-            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_132] = [__v_9];
+            record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -15554,8 +14997,8 @@ fn aiur_fn_129(
         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_129] = [__v_77];
-        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_132] = [__v_77];
+        record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -15592,8 +15035,8 @@ fn aiur_fn_129(
         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_129] = [__v_77];
-        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_132] = [__v_77];
+        record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
@@ -15630,8 +15073,8 @@ fn aiur_fn_129(
         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_129] = [__v_77];
-        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_132] = [__v_77];
+        record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
@@ -15668,8 +15111,8 @@ fn aiur_fn_129(
         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_129] = [__v_77];
-        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_132] = [__v_77];
+        record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
@@ -15706,8 +15149,8 @@ fn aiur_fn_129(
         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_129] = [__v_77];
-        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_132] = [__v_77];
+        record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15717,15 +15160,15 @@ fn aiur_fn_129(
   })
 }
 
-const INPUT_SIZE_130: usize = 45;
-const IN_130: usize = 45;
-const OUT_130: usize = 1;
-fn aiur_fn_130(
-  inp: [G; IN_130],
+const INPUT_SIZE_133: usize = 45;
+const IN_133: usize = 45;
+const OUT_133: usize = 1;
+fn aiur_fn_133(
+  inp: [G; IN_133],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_130], ExecError> {
+) -> Result<[G; OUT_133], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15776,26 +15219,26 @@ fn aiur_fn_130(
       1u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } else { aiur_fn_782(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__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_130] = [__v_47];
-            record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_133] = [__v_47];
+            record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
         let __v_45: G = G::from_u64(1);
-        let __ret: [G; OUT_130] = [__v_45];
-        record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_133] = [__v_45];
+        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_45: G = G::from_u64(1);
-        let __ret: [G; OUT_130] = [__v_45];
-        record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_133] = [__v_45];
+        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15805,15 +15248,15 @@ fn aiur_fn_130(
   })
 }
 
-const INPUT_SIZE_131: usize = 1;
-const IN_131: usize = 1;
-const OUT_131: usize = 1;
-fn aiur_fn_131(
-  inp: [G; IN_131],
+const INPUT_SIZE_134: usize = 1;
+const IN_134: usize = 1;
+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_131], ExecError> {
+) -> Result<[G; OUT_134], 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 };
@@ -15867,18 +15310,18 @@ fn aiur_fn_131(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_48: G = G::from_u64(0);
-        let __ret: [G; OUT_131] = [__v_48];
-        record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_134] = [__v_48];
+        record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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_48: G = __r_arr[0];
-        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__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 __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_47]; 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_49: G = __r_arr[0];
         let __v_50: G = (__v_48 + __v_49);
-        let __ret: [G; OUT_131] = [__v_50];
-        record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_134] = [__v_50];
+        record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15888,23 +15331,23 @@ fn aiur_fn_131(
   })
 }
 
-const INPUT_SIZE_132: usize = 2;
-const IN_132: usize = 2;
-const OUT_132: usize = 1;
-fn aiur_fn_132(
-  inp: [G; IN_132],
+const INPUT_SIZE_135: usize = 2;
+const IN_135: usize = 2;
+const OUT_135: usize = 1;
+fn aiur_fn_135(
+  inp: [G; IN_135],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_132], ExecError> {
+) -> Result<[G; OUT_135], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_132] = [__v_2];
-        record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_135] = [__v_2];
+        record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15958,15 +15401,15 @@ fn aiur_fn_132(
         let __v_48: G = __loaded[46];
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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_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_132] = { let __args: [G; IN_132] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_48, __v_51]; 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_52: G = __r_arr[0];
             let __v_53: G = (__v_49 + __v_52);
-            let __ret: [G; OUT_132] = [__v_53];
-            record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_135] = [__v_53];
+            record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -15978,15 +15421,15 @@ fn aiur_fn_132(
   })
 }
 
-const INPUT_SIZE_133: usize = 2;
-const IN_133: usize = 2;
-const OUT_133: usize = 1;
-fn aiur_fn_133(
-  inp: [G; IN_133],
+const INPUT_SIZE_136: usize = 2;
+const IN_136: usize = 2;
+const OUT_136: usize = 1;
+fn aiur_fn_136(
+  inp: [G; IN_136],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_133], ExecError> {
+) -> Result<[G; OUT_136], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15997,35 +15440,35 @@ fn aiur_fn_133(
     let __v_5: G = __loaded[3];
     let __v_6: G = __loaded[4];
     let __v_7: G = __loaded[5];
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     match __v_8.as_canonical_u64() {
       4294967295u64 => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_133] = [__v_9];
-        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_136] = [__v_9];
+        record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_8 - __v_9);
-        let __ret: [G; OUT_133] = [__v_10];
-        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_136] = [__v_10];
+        record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_134: usize = 2;
-const IN_134: usize = 2;
-const OUT_134: usize = 6;
-fn aiur_fn_134(
-  inp: [G; IN_134],
+const INPUT_SIZE_137: usize = 2;
+const IN_137: usize = 2;
+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_134], ExecError> {
+) -> Result<[G; OUT_137], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16037,8 +15480,8 @@ fn aiur_fn_134(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_134] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6];
-        record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_137] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6];
+        record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -16050,22 +15493,22 @@ fn aiur_fn_134(
           0u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_6 + __v_8);
-            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_4, __v_7]; 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_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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
             let __v_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_134] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-            record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_137] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+            record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -16080,15 +15523,15 @@ fn aiur_fn_134(
   })
 }
 
-const INPUT_SIZE_135: usize = 7;
-const IN_135: usize = 7;
-const OUT_135: usize = 6;
-fn aiur_fn_135(
-  inp: [G; IN_135],
+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_135], ExecError> {
+) -> Result<[G; OUT_138], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16103,8 +15546,8 @@ fn aiur_fn_135(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_135] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 => {
@@ -16159,22 +15602,22 @@ fn aiur_fn_135(
         let __v_57: G = __loaded[47];
         match __v_10.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_56, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_56, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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_135] = { let __args: [G; IN_135] = [__v_9, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_9, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; 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_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_135] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69];
-            record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_138] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69];
+            record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -16186,15 +15629,15 @@ fn aiur_fn_135(
   })
 }
 
-const INPUT_SIZE_136: usize = 7;
-const IN_136: usize = 7;
-const OUT_136: usize = 6;
-fn aiur_fn_136(
-  inp: [G; IN_136],
+const INPUT_SIZE_139: usize = 7;
+const IN_139: usize = 7;
+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_136], ExecError> {
+) -> Result<[G; OUT_139], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16209,46 +15652,46 @@ fn aiur_fn_136(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_136] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_139] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
+        record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__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[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__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[766].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = []; 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_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
             let __v_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_136] = { let __args: [G; IN_136] = [__v_9, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_9, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
             let __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_136] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24];
-            record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_139] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24];
+            record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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_136] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17];
-            record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_139] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17];
+            record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -16260,42 +15703,42 @@ fn aiur_fn_136(
   })
 }
 
-const INPUT_SIZE_137: usize = 2;
-const IN_137: usize = 2;
-const OUT_137: usize = 6;
-fn aiur_fn_137(
-  inp: [G; IN_137],
+const INPUT_SIZE_140: usize = 2;
+const IN_140: usize = 2;
+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_137], ExecError> {
+) -> Result<[G; OUT_140], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(1);
     let __v_3: G = G::from_u64(1);
-    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__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[138].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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[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_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_137] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
-    record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_140] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
+    record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_138: usize = 8;
-const IN_138: usize = 8;
-const OUT_138: usize = 6;
-fn aiur_fn_138(
-  inp: [G; IN_138],
+const INPUT_SIZE_141: usize = 8;
+const IN_141: usize = 8;
+const OUT_141: usize = 6;
+fn aiur_fn_141(
+  inp: [G; IN_141],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_138], ExecError> {
+) -> Result<[G; OUT_141], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16311,8 +15754,8 @@ fn aiur_fn_138(
     let __v_10: G = __loaded[2];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_138] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_141] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -16322,22 +15765,22 @@ fn aiur_fn_138(
         let __v_13: G = __loaded[2];
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
             let __v_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_138] = { let __args: [G; IN_138] = [__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[138].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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[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_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_138] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-            record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_141] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+            record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -16352,15 +15795,15 @@ fn aiur_fn_138(
   })
 }
 
-const INPUT_SIZE_139: usize = 2;
-const IN_139: usize = 2;
-const OUT_139: usize = 1;
-fn aiur_fn_139(
-  inp: [G; IN_139],
+const INPUT_SIZE_142: usize = 2;
+const IN_142: usize = 2;
+const OUT_142: usize = 1;
+fn aiur_fn_142(
+  inp: [G; IN_142],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_139], ExecError> {
+) -> Result<[G; OUT_142], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16371,23 +15814,23 @@ fn aiur_fn_139(
     let __v_5: G = __loaded[3];
     let __v_6: G = __loaded[4];
     let __v_7: G = __loaded[5];
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_139] = [__v_8];
-    record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_142] = [__v_8];
+    record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_140: usize = 2;
-const IN_140: usize = 2;
-const OUT_140: usize = 1;
-fn aiur_fn_140(
-  inp: [G; IN_140],
+const INPUT_SIZE_143: usize = 2;
+const IN_143: usize = 2;
+const OUT_143: usize = 1;
+fn aiur_fn_143(
+  inp: [G; IN_143],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_140], ExecError> {
+) -> Result<[G; OUT_143], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16398,8 +15841,8 @@ fn aiur_fn_140(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_140] = [__v_5];
-        record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_143] = [__v_5];
+        record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -16407,15 +15850,15 @@ fn aiur_fn_140(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_140] = [__v_6];
-            record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_143] = [__v_6];
+            record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_4]; 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_140] = [__v_6];
-            record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_143] = [__v_6];
+            record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -16427,15 +15870,15 @@ fn aiur_fn_140(
   })
 }
 
-const INPUT_SIZE_141: usize = 48;
-const IN_141: usize = 48;
-const OUT_141: usize = 1;
-fn aiur_fn_141(
-  inp: [G; IN_141],
+const INPUT_SIZE_144: usize = 48;
+const IN_144: usize = 48;
+const OUT_144: usize = 1;
+fn aiur_fn_144(
+  inp: [G; IN_144],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_141], ExecError> {
+) -> Result<[G; OUT_144], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16489,19 +15932,19 @@ fn aiur_fn_141(
       _ => {
         match __v_0.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_1]; 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_48: G = __r_arr[0];
             match __v_48.as_canonical_u64() {
               0u64 => {
                 let __v_49: G = G::from_u64(0);
-                let __ret: [G; OUT_141] = [__v_49];
-                record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_144] = [__v_49];
+                record.function_queries[144].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_141] = [__v_49];
-                record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_144] = [__v_49];
+                record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -16511,8 +15954,8 @@ fn aiur_fn_141(
           },
           _ => {
             let __v_48: G = G::from_u64(0);
-            let __ret: [G; OUT_141] = [__v_48];
-            record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_144] = [__v_48];
+            record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -16521,15 +15964,15 @@ fn aiur_fn_141(
   })
 }
 
-const INPUT_SIZE_142: usize = 1;
-const IN_142: usize = 1;
-const OUT_142: usize = 1;
-fn aiur_fn_142(
-  inp: [G; IN_142],
+const INPUT_SIZE_145: usize = 1;
+const IN_145: usize = 1;
+const OUT_145: usize = 1;
+fn aiur_fn_145(
+  inp: [G; IN_145],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_142], ExecError> {
+) -> Result<[G; OUT_145], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -16635,45 +16078,45 @@ fn aiur_fn_142(
             match __v_2.as_canonical_u64() {
               1u64 => {
                 let __v_95: G = G::from_u64(1);
-                let __ret: [G; OUT_142] = [__v_95];
-                record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_145] = [__v_95];
+                record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_95: G = G::from_u64(0);
-                let __ret: [G; OUT_142] = [__v_95];
-                record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_145] = [__v_95];
+                record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_95: G = G::from_u64(0);
-            let __ret: [G; OUT_142] = [__v_95];
-            record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_145] = [__v_95];
+            record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_48: G = G::from_u64(0);
-        let __ret: [G; OUT_142] = [__v_48];
-        record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_145] = [__v_48];
+        record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_143: usize = 3;
-const IN_143: usize = 3;
-const OUT_143: usize = 1;
-fn aiur_fn_143(
-  inp: [G; IN_143],
+const INPUT_SIZE_146: usize = 3;
+const IN_146: usize = 3;
+const OUT_146: usize = 1;
+fn aiur_fn_146(
+  inp: [G; IN_146],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_143], ExecError> {
+) -> Result<[G; OUT_146], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16685,8 +16128,8 @@ fn aiur_fn_143(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_143] = [__v_6];
-        record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_146] = [__v_6];
+        record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -16699,15 +16142,15 @@ fn aiur_fn_143(
             let __v_9: G = (__v_4 - __v_0);
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_143] = [__v_7];
-                record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_146] = [__v_7];
+                record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_0, __v_5, __v_8]; 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_10: G = __r_arr[0];
-                let __ret: [G; OUT_143] = [__v_10];
-                record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_146] = [__v_10];
+                record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -16724,15 +16167,15 @@ fn aiur_fn_143(
   })
 }
 
-const INPUT_SIZE_144: usize = 3;
-const IN_144: usize = 3;
-const OUT_144: usize = 3;
-fn aiur_fn_144(
-  inp: [G; IN_144],
+const INPUT_SIZE_147: usize = 3;
+const IN_147: usize = 3;
+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_144], ExecError> {
+) -> Result<[G; OUT_147], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16743,25 +16186,25 @@ fn aiur_fn_144(
     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_145] = { let __args: [G; IN_145] = [__v_0, __v_1, __v_2, __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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_0, __v_1, __v_2, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
     let __v_11: G = __r_arr[2];
-    let __ret: [G; OUT_144] = [__v_9, __v_10, __v_11];
-    record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_147] = [__v_9, __v_10, __v_11];
+    record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_145: usize = 5;
-const IN_145: usize = 5;
-const OUT_145: usize = 3;
-fn aiur_fn_145(
-  inp: [G; IN_145],
+const INPUT_SIZE_148: usize = 5;
+const IN_148: usize = 5;
+const OUT_148: usize = 3;
+fn aiur_fn_148(
+  inp: [G; IN_148],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_145], ExecError> {
+) -> Result<[G; OUT_148], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16780,8 +16223,8 @@ fn aiur_fn_145(
         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_145] = [__v_10, __v_13, __v_2];
-        record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_148] = [__v_10, __v_13, __v_2];
+        record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -16844,7 +16287,7 @@ fn aiur_fn_145(
               _ => {
                 match __v_8.as_canonical_u64() {
                   8u64 => {
-                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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_59: G = __r_arr[0];
                     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_59.as_canonical_u64() {
   0u64 => {
@@ -16852,7 +16295,7 @@ fn aiur_fn_145(
     break '__mc_0 [__v_60];
   },
   _ => {
-    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_59, __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 __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_59, __v_3]; 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];
     break '__mc_0 [__v_60];
   },
@@ -16861,9 +16304,9 @@ fn aiur_fn_145(
                     let __v_60: G = __mc_out___mc_0[0];
                     match __v_60.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_59, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_59, __v_3, __v_4]; 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_61: G = __r_arr[0];
-                        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_2, __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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                         let __v_62: G = __r_arr[0];
                         let __v_63: G = __r_arr[1];
                         let __v_64: G = __r_arr[2];
@@ -16871,12 +16314,12 @@ fn aiur_fn_145(
                         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_145] = [__v_66, __v_68, __v_64];
-                        record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_148] = [__v_66, __v_68, __v_64];
+                        record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_9]; 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_61: G = __r_arr[0];
                         let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_59.as_canonical_u64() {
   0u64 => {
@@ -16903,7 +16346,7 @@ fn aiur_fn_145(
  };
                         let __v_63: G = __mc_out___mc_2[0];
                         let __v_64: G = (__v_2 + __v_61);
-                        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_64, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_7, __v_58, __v_64, __v_62, __v_63]; 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_65: G = __r_arr[0];
                         let __v_66: G = __r_arr[1];
                         let __v_67: G = __r_arr[2];
@@ -16911,8 +16354,8 @@ fn aiur_fn_145(
                         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_145] = [__v_69, __v_71, __v_67];
-                        record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_148] = [__v_69, __v_71, __v_67];
+                        record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -16921,83 +16364,83 @@ fn aiur_fn_145(
                     }
                   },
                   6u64 => {
-                    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_2, __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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                     let __v_59: G = __r_arr[0];
                     let __v_60: G = __r_arr[1];
                     let __v_61: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_59, __v_60, __v_61];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_148] = [__v_59, __v_60, __v_61];
+                    record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   4u64 => {
-                    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_2, __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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                     let __v_59: G = __r_arr[0];
                     let __v_60: G = __r_arr[1];
                     let __v_61: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_59, __v_60, __v_61];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_148] = [__v_59, __v_60, __v_61];
+                    record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   5u64 => {
-                    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_2, __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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                     let __v_59: G = __r_arr[0];
                     let __v_60: G = __r_arr[1];
                     let __v_61: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_59, __v_60, __v_61];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_148] = [__v_59, __v_60, __v_61];
+                    record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   7u64 => {
-                    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_2, __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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                     let __v_59: G = __r_arr[0];
                     let __v_60: G = __r_arr[1];
                     let __v_61: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_59, __v_60, __v_61];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_148] = [__v_59, __v_60, __v_61];
+                    record.function_queries[148].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_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_60, __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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                     let __v_61: G = __r_arr[0];
                     let __v_62: G = __r_arr[1];
                     let __v_63: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_61, __v_62, __v_63];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_148] = [__v_61, __v_62, __v_63];
+                    record.function_queries[148].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_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_60, __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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                     let __v_61: G = __r_arr[0];
                     let __v_62: G = __r_arr[1];
                     let __v_63: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_61, __v_62, __v_63];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_148] = [__v_61, __v_62, __v_63];
+                    record.function_queries[148].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_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_60, __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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                     let __v_61: G = __r_arr[0];
                     let __v_62: G = __r_arr[1];
                     let __v_63: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_61, __v_62, __v_63];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_148] = [__v_61, __v_62, __v_63];
+                    record.function_queries[148].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_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_60, __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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                     let __v_61: G = __r_arr[0];
                     let __v_62: G = __r_arr[1];
                     let __v_63: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_61, __v_62, __v_63];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_148] = [__v_61, __v_62, __v_63];
+                    record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -17019,15 +16462,15 @@ fn aiur_fn_145(
   })
 }
 
-const INPUT_SIZE_146: usize = 4;
-const IN_146: usize = 4;
-const OUT_146: usize = 1;
-fn aiur_fn_146(
-  inp: [G; IN_146],
+const INPUT_SIZE_149: usize = 4;
+const IN_149: usize = 4;
+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_146], ExecError> {
+) -> Result<[G; OUT_149], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17039,23 +16482,23 @@ fn aiur_fn_146(
     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_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_3, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1, __v_2, __v_3, __v_6, __v_9]; 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_10: G = __r_arr[0];
-    let __ret: [G; OUT_146] = [__v_10];
-    record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_149] = [__v_10];
+    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_147: usize = 6;
-const IN_147: usize = 6;
-const OUT_147: usize = 1;
-fn aiur_fn_147(
-  inp: [G; IN_147],
+const INPUT_SIZE_150: usize = 6;
+const IN_150: usize = 6;
+const OUT_150: usize = 1;
+fn aiur_fn_150(
+  inp: [G; IN_150],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_147], ExecError> {
+) -> Result<[G; OUT_150], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17072,8 +16515,8 @@ fn aiur_fn_147(
         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_147] = [__v_11];
-        record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_150] = [__v_11];
+        record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -17136,7 +16579,7 @@ fn aiur_fn_147(
               _ => {
                 match __v_9.as_canonical_u64() {
                   8u64 => {
-                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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_60: G = __r_arr[0];
                     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_60.as_canonical_u64() {
   0u64 => {
@@ -17144,7 +16587,7 @@ fn aiur_fn_147(
     break '__mc_0 [__v_61];
   },
   _ => {
-    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_60, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_60, __v_4]; 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_61: G = __r_arr[0];
     break '__mc_0 [__v_61];
   },
@@ -17153,18 +16596,18 @@ fn aiur_fn_147(
                     let __v_61: G = __mc_out___mc_0[0];
                     match __v_61.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_60, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_60, __v_4, __v_5]; 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_62: G = __r_arr[0];
                         let __v_63: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; 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_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_147] = [__v_65];
-                        record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_150] = [__v_65];
+                        record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_10]; 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_62: G = __r_arr[0];
                         let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_60.as_canonical_u64() {
   0u64 => {
@@ -17192,11 +16635,11 @@ fn aiur_fn_147(
                         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_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_66, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_8, __v_59, __v_2, __v_66, __v_63, __v_64]; 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_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_147] = [__v_68];
-                        record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_150] = [__v_68];
+                        record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -17207,9 +16650,9 @@ fn aiur_fn_147(
                   6u64 => {
                     match __v_10.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_18, __v_2]; 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];
-                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_18]; 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_61: G = __r_arr[0];
                         let __v_62: G = __r_arr[1];
                         let __v_63: G = __r_arr[2];
@@ -17262,17 +16705,17 @@ fn aiur_fn_147(
                           _ => {
                             match __v_61.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                                 let __v_109: G = __r_arr[0];
-                                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_62, __v_109]; 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_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_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; 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_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_147] = [__v_114];
-                                record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_150] = [__v_114];
+                                record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -17287,9 +16730,9 @@ fn aiur_fn_147(
                   4u64 => {
                     match __v_10.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_26, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_26, __v_2]; 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];
-                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_26]; 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_61: G = __r_arr[0];
                         let __v_62: G = __r_arr[1];
                         let __v_63: G = __r_arr[2];
@@ -17342,22 +16785,22 @@ fn aiur_fn_147(
                           _ => {
                             match __v_61.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                                 let __v_109: G = __r_arr[0];
-                                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_62, __v_109]; 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_110: G = __r_arr[0];
                                 let __v_111: G = G::from_u64(0);
                                 let __v_112: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                                 let __v_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_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; 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_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_147] = [__v_118];
-                                record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_150] = [__v_118];
+                                record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -17372,9 +16815,9 @@ fn aiur_fn_147(
                   5u64 => {
                     match __v_10.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_18, __v_2]; 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];
-                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_18]; 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_61: G = __r_arr[0];
                         let __v_62: G = __r_arr[1];
                         let __v_63: G = __r_arr[2];
@@ -17427,17 +16870,17 @@ fn aiur_fn_147(
                           _ => {
                             match __v_61.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                                 let __v_109: G = __r_arr[0];
-                                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_62, __v_109]; 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_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_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; 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_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_147] = [__v_114];
-                                record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_150] = [__v_114];
+                                record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -17452,9 +16895,9 @@ fn aiur_fn_147(
                   7u64 => {
                     match __v_10.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_18, __v_2]; 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];
-                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_18]; 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_61: G = __r_arr[0];
                         let __v_62: G = __r_arr[1];
                         let __v_63: G = __r_arr[2];
@@ -17507,17 +16950,17 @@ fn aiur_fn_147(
                           _ => {
                             match __v_61.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                                 let __v_109: G = __r_arr[0];
-                                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_62, __v_109]; 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_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_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; 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_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_147] = [__v_114];
-                                record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_150] = [__v_114];
+                                record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -17533,11 +16976,11 @@ fn aiur_fn_147(
                     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_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_62, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_8, __v_59, __v_2, __v_62, __v_4, __v_5]; 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_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_147] = [__v_64];
-                    record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_150] = [__v_64];
+                    record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -17556,15 +16999,15 @@ fn aiur_fn_147(
   })
 }
 
-const INPUT_SIZE_148: usize = 2;
-const IN_148: usize = 2;
-const OUT_148: usize = 2;
-fn aiur_fn_148(
-  inp: [G; IN_148],
+const INPUT_SIZE_151: usize = 2;
+const IN_151: usize = 2;
+const OUT_151: usize = 2;
+fn aiur_fn_151(
+  inp: [G; IN_151],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_148], ExecError> {
+) -> Result<[G; OUT_151], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17580,12 +17023,12 @@ fn aiur_fn_148(
         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_148] = [__v_7, __v_10];
-        record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_151] = [__v_7, __v_10];
+        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: 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 };
@@ -17595,19 +17038,19 @@ fn aiur_fn_148(
         let __v_10: G = __loaded[3];
         let __v_11: G = __loaded[4];
         let __v_12: G = __loaded[5];
-        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         match __v_13.as_canonical_u64() {
           4294967295u64 => {
-            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__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_14: G = __r_arr[0];
             let __v_15: G = G::from_u64(0);
             let __v_16: G = G::from_u64(0);
             let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __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_18: G = G::from_u64(0);
             let __v_19: G = { let __values: [G; 3] = [__v_18, __v_14, __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_148] = [__v_17, __v_19];
-            record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_151] = [__v_17, __v_19];
+            record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -17620,8 +17063,8 @@ fn aiur_fn_148(
             let __v_20: G = G::from_u64(1);
             let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_22: G = { let __values: [G; 3] = [__v_18, __v_21, __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_148] = [__v_17, __v_22];
-            record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_151] = [__v_17, __v_22];
+            record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -17633,15 +17076,15 @@ fn aiur_fn_148(
   })
 }
 
-const INPUT_SIZE_149: usize = 1;
-const IN_149: usize = 1;
-const OUT_149: usize = 1;
-fn aiur_fn_149(
-  inp: [G; IN_149],
+const INPUT_SIZE_152: usize = 1;
+const IN_152: usize = 1;
+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_149], ExecError> {
+) -> Result<[G; OUT_152], 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 };
@@ -17697,18 +17140,18 @@ fn aiur_fn_149(
       _ => {
         match __v_1.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_2]; 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_49: G = __r_arr[0];
             match __v_49.as_canonical_u64() {
               0u64 => {
                 let __v_50: G = G::from_u64(0);
-                let __ret: [G; OUT_149] = [__v_50];
-                record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_152] = [__v_50];
+                record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __ret: [G; OUT_149] = [__v_0];
-                record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_152] = [__v_0];
+                record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -17718,8 +17161,8 @@ fn aiur_fn_149(
           },
           _ => {
             let __v_49: G = G::from_u64(0);
-            let __ret: [G; OUT_149] = [__v_49];
-            record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_152] = [__v_49];
+            record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -17728,15 +17171,15 @@ fn aiur_fn_149(
   })
 }
 
-const INPUT_SIZE_150: usize = 4;
-const IN_150: usize = 4;
-const OUT_150: usize = 1;
-fn aiur_fn_150(
-  inp: [G; IN_150],
+const INPUT_SIZE_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_150], ExecError> {
+) -> Result<[G; OUT_153], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17748,8 +17191,8 @@ fn aiur_fn_150(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_150] = [__v_3];
-        record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_153] = [__v_3];
+        record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -17762,15 +17205,15 @@ fn aiur_fn_150(
             let __v_10: G = (__v_5 - __v_0);
             match __v_10.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_150] = [__v_8];
-                record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_153] = [__v_8];
+                record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_6, __v_9, __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 __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_6, __v_9, __v_3]; 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_150] = [__v_11];
-                record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_153] = [__v_11];
+                record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -17787,15 +17230,15 @@ fn aiur_fn_150(
   })
 }
 
-const INPUT_SIZE_151: usize = 4;
-const IN_151: usize = 4;
-const OUT_151: usize = 1;
-fn aiur_fn_151(
-  inp: [G; IN_151],
+const INPUT_SIZE_154: usize = 4;
+const IN_154: usize = 4;
+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_151], ExecError> {
+) -> Result<[G; OUT_154], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17810,8 +17253,8 @@ fn aiur_fn_151(
         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_151] = [__v_9];
-        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_154] = [__v_9];
+        record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -17821,14 +17264,14 @@ fn aiur_fn_151(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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 __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_5]; 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_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_150] = { let __args: [G; IN_150] = [__v_10, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_10, __v_2, __v_3, __v_8]; 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_11: G = __r_arr[0];
     break '__mc_0 [__v_11];
   },
@@ -17860,11 +17303,11 @@ fn aiur_fn_151(
  };
             let __v_13: G = __mc_out___mc_2[0];
             let __v_14: G = G::from_u64(0);
-            let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_6, __v_9, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_6, __v_9, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
             let __v_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_151] = [__v_16];
-            record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_154] = [__v_16];
+            record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -17879,15 +17322,15 @@ fn aiur_fn_151(
   })
 }
 
-const INPUT_SIZE_152: usize = 2;
-const IN_152: usize = 2;
-const OUT_152: usize = 1;
-fn aiur_fn_152(
-  inp: [G; IN_152],
+const INPUT_SIZE_155: usize = 2;
+const IN_155: usize = 2;
+const OUT_155: usize = 1;
+fn aiur_fn_155(
+  inp: [G; IN_155],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_152], ExecError> {
+) -> Result<[G; OUT_155], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17897,23 +17340,23 @@ fn aiur_fn_152(
     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_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_152] = [__v_8];
-    record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_155] = [__v_8];
+    record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_153: usize = 10;
-const IN_153: usize = 10;
-const OUT_153: usize = 6;
-fn aiur_fn_153(
-  inp: [G; IN_153],
+const INPUT_SIZE_156: usize = 10;
+const IN_156: usize = 10;
+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_153], ExecError> {
+) -> Result<[G; OUT_156], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17931,8 +17374,8 @@ fn aiur_fn_153(
     let __v_12: G = __loaded[2];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_153] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
-        record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_156] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
+        record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -17942,44 +17385,44 @@ fn aiur_fn_153(
         let __v_15: G = __loaded[2];
         match __v_13.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
             match __v_16.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__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[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__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[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_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_153] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-                record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_156] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
+                record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_16, __v_2, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_16, __v_2, __v_3, __v_11]; 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_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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
                 let __v_23: G = __r_arr[1];
                 let __v_24: G = __r_arr[2];
                 let __v_25: G = __r_arr[3];
                 let __v_26: G = __r_arr[4];
                 let __v_27: G = __r_arr[5];
-                let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__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[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__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[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
                 let __v_28: G = __r_arr[0];
                 let __v_29: G = __r_arr[1];
                 let __v_30: G = __r_arr[2];
                 let __v_31: G = __r_arr[3];
                 let __v_32: G = __r_arr[4];
                 let __v_33: G = __r_arr[5];
-                let __ret: [G; OUT_153] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-                record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_156] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
+                record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -17996,15 +17439,15 @@ fn aiur_fn_153(
   })
 }
 
-const INPUT_SIZE_154: usize = 2;
-const IN_154: usize = 2;
-const OUT_154: usize = 6;
-fn aiur_fn_154(
-  inp: [G; IN_154],
+const INPUT_SIZE_157: usize = 2;
+const IN_157: usize = 2;
+const OUT_157: usize = 6;
+fn aiur_fn_157(
+  inp: [G; IN_157],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_154], ExecError> {
+) -> Result<[G; OUT_157], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18016,28 +17459,28 @@ fn aiur_fn_154(
     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_153] = { let __args: [G; IN_153] = [__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[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__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[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_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_154] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-    record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_157] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+    record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_155: usize = 2;
-const IN_155: usize = 2;
-const OUT_155: usize = 1;
-fn aiur_fn_155(
-  inp: [G; IN_155],
+const INPUT_SIZE_158: usize = 2;
+const IN_158: usize = 2;
+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_155], ExecError> {
+) -> Result<[G; OUT_158], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18050,8 +17493,8 @@ fn aiur_fn_155(
     let __v_7: G = __loaded[5];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_155] = [__v_0];
-        record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_158] = [__v_0];
+        record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -18062,46 +17505,46 @@ fn aiur_fn_155(
         let __v_11: G = __loaded[3];
         let __v_12: G = __loaded[4];
         let __v_13: G = __loaded[5];
-        let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__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[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__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[766].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_155] = [__v_14];
-        record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_158] = [__v_14];
+        record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_156: usize = 3;
-const IN_156: usize = 3;
-const OUT_156: usize = 1;
-fn aiur_fn_156(
-  inp: [G; IN_156],
+const INPUT_SIZE_159: usize = 3;
+const IN_159: usize = 3;
+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_156], ExecError> {
+) -> Result<[G; OUT_159], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_0, __v_1]; 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_3: G = __r_arr[0];
-    let __ret: [G; OUT_156] = [__v_3];
-    record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_159] = [__v_3];
+    record.function_queries[159].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],
+const INPUT_SIZE_160: usize = 2;
+const IN_160: usize = 2;
+const OUT_160: usize = 1;
+fn aiur_fn_160(
+  inp: [G; IN_160],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_157], ExecError> {
+) -> Result<[G; OUT_160], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18158,20 +17601,20 @@ fn aiur_fn_157(
         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_157] = [__v_51];
-        record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_160] = [__v_51];
+        record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_49: G = G::from_u64(0);
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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_50: G = __r_arr[0];
         let __v_51: G = (__v_1 + __v_50);
-        let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_48, __v_51]; 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_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_157] = [__v_53];
-        record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_160] = [__v_53];
+        record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -18181,15 +17624,15 @@ fn aiur_fn_157(
   })
 }
 
-const INPUT_SIZE_158: usize = 3;
-const IN_158: usize = 3;
-const OUT_158: usize = 1;
-fn aiur_fn_158(
-  inp: [G; IN_158],
+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_158], ExecError> {
+) -> Result<[G; OUT_161], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18199,8 +17642,8 @@ fn aiur_fn_158(
         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_158] = [__v_5];
-        record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_161] = [__v_5];
+        record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -18212,47 +17655,47 @@ fn aiur_fn_158(
         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_158] = { let __args: [G; IN_158] = [__v_8, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_8, __v_1, __v_10]; 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_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_158] = [__v_12];
-        record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_161] = [__v_12];
+        record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_159: usize = 3;
-const IN_159: usize = 3;
-const OUT_159: usize = 1;
-fn aiur_fn_159(
-  inp: [G; IN_159],
+const INPUT_SIZE_162: usize = 3;
+const IN_162: usize = 3;
+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_159], ExecError> {
+) -> Result<[G; OUT_162], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_159] = [__v_3];
-    record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_162] = [__v_3];
+    record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_160: usize = 2;
-const IN_160: usize = 2;
-const OUT_160: usize = 1;
-fn aiur_fn_160(
-  inp: [G; IN_160],
+const INPUT_SIZE_163: usize = 2;
+const IN_163: usize = 2;
+const OUT_163: usize = 1;
+fn aiur_fn_163(
+  inp: [G; IN_163],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_160], ExecError> {
+) -> Result<[G; OUT_163], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18309,8 +17752,8 @@ fn aiur_fn_160(
         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_160] = [__v_51];
-        record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_163] = [__v_51];
+        record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -18318,20 +17761,20 @@ fn aiur_fn_160(
           1u64 => {
             match __v_4.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } else { aiur_fn_782(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__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_158] = { let __args: [G; IN_158] = [__v_49, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_49, __v_1, __v_50]; 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_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_160] = { let __args: [G; IN_160] = [__v_48, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_48, __v_54]; 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_55: G = __r_arr[0];
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_51, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_51, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
                 let __v_56: G = __r_arr[0];
-                let __ret: [G; OUT_160] = [__v_56];
-                record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_163] = [__v_56];
+                record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -18339,19 +17782,19 @@ fn aiur_fn_160(
           0u64 => {
             let __v_49: G = G::from_u64(1);
             let __v_50: G = (__v_1 + __v_49);
-            let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_48, __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 __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_48, __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_51: G = __r_arr[0];
-            let __ret: [G; OUT_160] = [__v_51];
-            record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_163] = [__v_51];
+            record.function_queries[163].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_160] = { let __args: [G; IN_160] = [__v_48, __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 __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_48, __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_51: G = __r_arr[0];
-            let __ret: [G; OUT_160] = [__v_51];
-            record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_163] = [__v_51];
+            record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -18366,15 +17809,15 @@ fn aiur_fn_160(
   })
 }
 
-const INPUT_SIZE_161: usize = 1;
-const IN_161: usize = 1;
-const OUT_161: usize = 1;
-fn aiur_fn_161(
-  inp: [G; IN_161],
+const INPUT_SIZE_164: usize = 1;
+const IN_164: usize = 1;
+const OUT_164: usize = 1;
+fn aiur_fn_164(
+  inp: [G; IN_164],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_161], ExecError> {
+) -> Result<[G; OUT_164], 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 };
@@ -18428,23 +17871,23 @@ fn aiur_fn_161(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_48: G = G::from_u64(0);
-        let __ret: [G; OUT_161] = [__v_48];
-        record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_164] = [__v_48];
+        record.function_queries[164].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_161] = [__v_48];
-            record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_164] = [__v_48];
+            record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_47]; 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_48: G = __r_arr[0];
-            let __ret: [G; OUT_161] = [__v_48];
-            record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_164] = [__v_48];
+            record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -18456,15 +17899,15 @@ fn aiur_fn_161(
   })
 }
 
-const INPUT_SIZE_162: usize = 19;
-const IN_162: usize = 19;
-const OUT_162: usize = 18;
-fn aiur_fn_162(
-  inp: [G; IN_162],
+const INPUT_SIZE_165: usize = 19;
+const IN_165: usize = 19;
+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_162], ExecError> {
+) -> Result<[G; OUT_165], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18487,9 +17930,9 @@ fn aiur_fn_162(
     let __v_18: G = inp[18];
     match __v_0.as_canonical_u64() {
       11u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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];
@@ -18516,7 +17959,7 @@ fn aiur_fn_162(
             let __v_39: G = __loaded[15];
             let __v_40: G = __loaded[16];
             let __v_41: G = __loaded[17];
-            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_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[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_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[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_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
             let __v_44: G = __r_arr[2];
@@ -18535,8 +17978,8 @@ fn aiur_fn_162(
             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_162] = [__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[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_165] = [__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[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -18545,23 +17988,23 @@ fn aiur_fn_162(
         }
       },
       _ => {
-        let __ret: [G; OUT_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __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[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_163: usize = 20;
-const IN_163: usize = 20;
-const OUT_163: usize = 18;
-fn aiur_fn_163(
-  inp: [G; IN_163],
+const INPUT_SIZE_166: usize = 20;
+const IN_166: usize = 20;
+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_163], ExecError> {
+) -> Result<[G; OUT_166], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18585,7 +18028,7 @@ fn aiur_fn_163(
     let __v_19: G = inp[19];
     match __v_18.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_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[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -18604,12 +18047,12 @@ fn aiur_fn_163(
         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_163] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __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[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_166] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __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[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_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[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -18651,7 +18094,7 @@ fn aiur_fn_163(
             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_163] = { let __args: [G; IN_163] = [__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[163].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__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[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_58: G = __r_arr[0];
             let __v_59: G = __r_arr[1];
             let __v_60: G = __r_arr[2];
@@ -18670,13 +18113,13 @@ fn aiur_fn_163(
             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_163] = [__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[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_166] = [__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[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_163] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __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[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_166] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __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[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -18685,15 +18128,15 @@ fn aiur_fn_163(
   })
 }
 
-const INPUT_SIZE_164: usize = 19;
-const IN_164: usize = 19;
-const OUT_164: usize = 18;
-fn aiur_fn_164(
-  inp: [G; IN_164],
+const INPUT_SIZE_167: usize = 19;
+const IN_167: usize = 19;
+const OUT_167: usize = 18;
+fn aiur_fn_167(
+  inp: [G; IN_167],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_164], ExecError> {
+) -> Result<[G; OUT_167], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18714,7 +18157,7 @@ fn aiur_fn_164(
     let __v_16: G = inp[16];
     let __v_17: G = inp[17];
     let __v_18: G = inp[18];
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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]; 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_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
     let __v_21: G = __r_arr[2];
@@ -18754,7 +18197,7 @@ fn aiur_fn_164(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__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[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__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[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_55: G = __r_arr[0];
         let __v_56: G = __r_arr[1];
         let __v_57: G = __r_arr[2];
@@ -18773,12 +18216,12 @@ fn aiur_fn_164(
         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_164] = [__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[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_167] = [__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[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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]; 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_37: G = __r_arr[0];
         let __v_38: G = __r_arr[1];
         let __v_39: G = __r_arr[2];
@@ -18797,23 +18240,23 @@ fn aiur_fn_164(
         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_164] = [__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[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_167] = [__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[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_165: usize = 21;
-const IN_165: usize = 21;
-const OUT_165: usize = 1;
-fn aiur_fn_165(
-  inp: [G; IN_165],
+const INPUT_SIZE_168: usize = 21;
+const IN_168: usize = 21;
+const OUT_168: usize = 1;
+fn aiur_fn_168(
+  inp: [G; IN_168],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_165], ExecError> {
+) -> Result<[G; OUT_168], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18836,7 +18279,7 @@ fn aiur_fn_165(
     let __v_18: G = inp[18];
     let __v_19: G = inp[19];
     let __v_20: G = inp[20];
-    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_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[163].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_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[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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -18876,7 +18319,7 @@ fn aiur_fn_165(
         let __v_54: G = __loaded[15];
         let __v_55: G = __loaded[16];
         let __v_56: G = __loaded[17];
-        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__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[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__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[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_57: G = __r_arr[0];
         let __v_58: G = __r_arr[1];
         let __v_59: G = __r_arr[2];
@@ -18897,12 +18340,12 @@ fn aiur_fn_165(
         let __v_74: G = __r_arr[17];
         match __v_57.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
             let __v_75: G = __r_arr[0];
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_19, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_19, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_76: G = __r_arr[0];
-            let __ret: [G; OUT_165] = [__v_76];
-            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_168] = [__v_76];
+            record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -18939,8 +18382,8 @@ fn aiur_fn_165(
             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_165] = [__v_107];
-            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_168] = [__v_107];
+            record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -18979,23 +18422,23 @@ fn aiur_fn_165(
         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_165] = [__v_71];
-        record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_168] = [__v_71];
+        record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_166: usize = 48;
-const IN_166: usize = 48;
-const OUT_166: usize = 2;
-fn aiur_fn_166(
-  inp: [G; IN_166],
+const INPUT_SIZE_169: usize = 48;
+const IN_169: usize = 48;
+const OUT_169: usize = 2;
+fn aiur_fn_169(
+  inp: [G; IN_169],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_166], ExecError> {
+) -> Result<[G; OUT_169], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -19066,20 +18509,20 @@ fn aiur_fn_166(
         let __v_63: G = __loaded[15];
         let __v_64: G = __loaded[16];
         let __v_65: G = __loaded[17];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_66: G = __r_arr[0];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_67: G = __r_arr[0];
         let __v_68: G = (__v_66 + __v_67);
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_69: G = __r_arr[0];
         let __v_70: G = (__v_68 + __v_69);
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_71: G = __r_arr[0];
         let __v_72: G = (__v_70 + __v_71);
-        let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__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[165].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__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[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_73: G = __r_arr[0];
-        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_73]; 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_74: G = __r_arr[0];
         let __v_75: G = __r_arr[1];
         let __v_76: G = __r_arr[2];
@@ -19134,7 +18577,7 @@ fn aiur_fn_166(
               6u64 => {
                 match __v_75.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_83]; 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_122: G = __r_arr[0];
                     let __v_123: G = __r_arr[1];
                     let __v_124: G = __r_arr[2];
@@ -19187,14 +18630,14 @@ fn aiur_fn_166(
                       _ => {
                         match __v_122.as_canonical_u64() {
                           8u64 => {
-                            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_83, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_83, __v_47]; 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_170: G = __r_arr[0];
-                            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                             let __v_171: G = __r_arr[0];
-                            let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_123, __v_170, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_123, __v_170, __v_171]; 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_172: G = __r_arr[0];
-                            let __ret: [G; OUT_166] = [__v_172, __v_83];
-                            record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_169] = [__v_172, __v_83];
+                            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -19217,37 +18660,37 @@ fn aiur_fn_166(
   })
 }
 
-const INPUT_SIZE_167: usize = 3;
-const IN_167: usize = 3;
-const OUT_167: usize = 1;
-fn aiur_fn_167(
-  inp: [G; IN_167],
+const INPUT_SIZE_170: usize = 3;
+const IN_170: usize = 3;
+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_167], ExecError> {
+) -> Result<[G; OUT_170], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_167] = [__v_4];
-    record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_170] = [__v_4];
+    record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_168: usize = 4;
-const IN_168: usize = 4;
-const OUT_168: usize = 1;
-fn aiur_fn_168(
-  inp: [G; IN_168],
+const INPUT_SIZE_171: usize = 4;
+const IN_171: usize = 4;
+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_168], ExecError> {
+) -> Result<[G; OUT_171], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -19306,12 +18749,12 @@ fn aiur_fn_168(
         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_168] = [__v_53];
-        record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_171] = [__v_53];
+        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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_51: G = __r_arr[0];
         let __v_52: G = (__v_3 - __v_2);
         let __v_53: G = G::from_bool((__v_52 == G::ZERO));
@@ -19321,13 +18764,13 @@ fn aiur_fn_168(
               1u64 => {
                 match __v_6.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } else { aiur_fn_782(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__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_158] = { let __args: [G; IN_158] = [__v_54, __v_1, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_54, __v_1, __v_55]; 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_56: G = __r_arr[0];
-                    let __ret: [G; OUT_168] = [__v_56];
-                    record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_171] = [__v_56];
+                    record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -19336,8 +18779,8 @@ fn aiur_fn_168(
                 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_168] = [__v_56];
-                record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_171] = [__v_56];
+                record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -19346,10 +18789,10 @@ fn aiur_fn_168(
             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_168] = { let __args: [G; IN_168] = [__v_50, __v_54, __v_2, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_50, __v_54, __v_2, __v_56]; 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_57: G = __r_arr[0];
-            let __ret: [G; OUT_168] = [__v_57];
-            record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_171] = [__v_57];
+            record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -19364,15 +18807,15 @@ fn aiur_fn_168(
   })
 }
 
-const INPUT_SIZE_169: usize = 57;
-const IN_169: usize = 57;
-const OUT_169: usize = 1;
-fn aiur_fn_169(
-  inp: [G; IN_169],
+const INPUT_SIZE_172: usize = 57;
+const IN_172: usize = 57;
+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_169], ExecError> {
+) -> Result<[G; OUT_172], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -19435,34 +18878,34 @@ fn aiur_fn_169(
       1u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } else { aiur_fn_782(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
             let __v_57: G = __r_arr[0];
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_50, __v_52]; 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_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_158] = { let __args: [G; IN_158] = [__v_57, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_57, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
             let __v_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_170] = { let __args: [G; IN_170] = [__v_27, __v_45, __v_46, __v_47, __v_48, __v_49, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_27, __v_45, __v_46, __v_47, __v_48, __v_49, __v_59]; 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_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_61, __v_56, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __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_169] = [__v_67];
-            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_172] = [__v_67];
+            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_50]; 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_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_159] = { let __args: [G; IN_159] = [__v_50, __v_51, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_50, __v_51, __v_58]; 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_59: G = __r_arr[0];
             let __v_60: G = G::from_u64(3);
             let __v_61: G = G::from_u64(0);
@@ -19471,8 +18914,8 @@ fn aiur_fn_169(
             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_169] = [__v_66];
-            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_172] = [__v_66];
+            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -19483,7 +18926,7 @@ fn aiur_fn_169(
 }
  };
             let __v_58: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[166].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[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_59: G = __r_arr[0];
             let __v_60: G = __r_arr[1];
             let __v_61: G = G::from_u64(3);
@@ -19493,8 +18936,8 @@ fn aiur_fn_169(
             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_169] = [__v_67];
-            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_172] = [__v_67];
+            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -19512,8 +18955,8 @@ fn aiur_fn_169(
         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_169] = [__v_65];
-        record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_172] = [__v_65];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -19523,15 +18966,15 @@ fn aiur_fn_169(
   })
 }
 
-const INPUT_SIZE_170: usize = 7;
-const IN_170: usize = 7;
-const OUT_170: usize = 1;
-fn aiur_fn_170(
-  inp: [G; IN_170],
+const INPUT_SIZE_173: usize = 7;
+const IN_173: usize = 7;
+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_170], ExecError> {
+) -> Result<[G; OUT_173], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -19582,8 +19025,8 @@ fn aiur_fn_170(
         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_170] = [__v_45];
-        record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_173] = [__v_45];
+        record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -19591,11 +19034,11 @@ fn aiur_fn_170(
         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_170] = { let __args: [G; IN_170] = [__v_42, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_42, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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_170] = [__v_48];
-        record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_173] = [__v_48];
+        record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -19605,15 +19048,15 @@ fn aiur_fn_170(
   })
 }
 
-const INPUT_SIZE_171: usize = 13;
-const IN_171: usize = 13;
-const OUT_171: usize = 1;
-fn aiur_fn_171(
-  inp: [G; IN_171],
+const INPUT_SIZE_174: usize = 13;
+const IN_174: usize = 13;
+const OUT_174: usize = 1;
+fn aiur_fn_174(
+  inp: [G; IN_174],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_171], ExecError> {
+) -> Result<[G; OUT_174], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -19681,21 +19124,21 @@ fn aiur_fn_171(
         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_171] = [__v_62];
-        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_174] = [__v_62];
+        record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[169].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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_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_171] = { let __args: [G; IN_171] = [__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[171].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[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_63: G = __r_arr[0];
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
         let __v_64: G = __r_arr[0];
-        let __ret: [G; OUT_171] = [__v_64];
-        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_174] = [__v_64];
+        record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -19705,15 +19148,15 @@ fn aiur_fn_171(
   })
 }
 
-const INPUT_SIZE_172: usize = 1;
-const IN_172: usize = 1;
-const OUT_172: usize = 2;
-fn aiur_fn_172(
-  inp: [G; IN_172],
+const INPUT_SIZE_175: usize = 1;
+const IN_175: usize = 1;
+const OUT_175: usize = 2;
+fn aiur_fn_175(
+  inp: [G; IN_175],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_172], ExecError> {
+) -> Result<[G; OUT_175], 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 };
@@ -19722,8 +19165,8 @@ fn aiur_fn_172(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_172] = [__v_2, __v_3];
-        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_175] = [__v_2, __v_3];
+        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -19733,15 +19176,15 @@ fn aiur_fn_172(
   })
 }
 
-const INPUT_SIZE_173: usize = 7;
-const IN_173: usize = 7;
-const OUT_173: usize = 1;
-fn aiur_fn_173(
-  inp: [G; IN_173],
+const INPUT_SIZE_176: usize = 7;
+const IN_176: usize = 7;
+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_173], ExecError> {
+) -> Result<[G; OUT_176], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -19750,14 +19193,14 @@ fn aiur_fn_173(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_2, __v_3]; 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_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_135] = { let __args: [G; IN_135] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
     let __v_15: G = __r_arr[2];
@@ -19768,23 +19211,23 @@ fn aiur_fn_173(
     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_174] = { let __args: [G; IN_174] = [__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[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[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_23: G = __r_arr[0];
-    let __ret: [G; OUT_173] = [__v_23];
-    record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_176] = [__v_23];
+    record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_174: usize = 9;
-const IN_174: usize = 9;
-const OUT_174: usize = 1;
-fn aiur_fn_174(
-  inp: [G; IN_174],
+const INPUT_SIZE_177: usize = 9;
+const IN_177: usize = 9;
+const OUT_177: usize = 1;
+fn aiur_fn_177(
+  inp: [G; IN_177],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_174], ExecError> {
+) -> Result<[G; OUT_177], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -19804,8 +19247,8 @@ fn aiur_fn_174(
         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_174] = [__v_14];
-        record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_177] = [__v_14];
+        record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -19858,14 +19301,14 @@ fn aiur_fn_174(
         let __v_57: G = __loaded[45];
         let __v_58: G = __loaded[46];
         let __v_59: G = __loaded[47];
-        let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_1]; 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 __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !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_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_141] = { let __args: [G; IN_141] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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_62: G = __r_arr[0];
                 let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_62.as_canonical_u64() {
   0u64 => {
@@ -19873,7 +19316,7 @@ fn aiur_fn_174(
     break '__mc_0 [__v_63];
   },
   _ => {
-    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_62, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_62, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
     let __v_63: G = __r_arr[0];
     break '__mc_0 [__v_63];
   },
@@ -19882,10 +19325,10 @@ fn aiur_fn_174(
                 let __v_63: G = __mc_out___mc_0[0];
                 match __v_63.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
                     let __v_64: G = __r_arr[0];
-                    let __ret: [G; OUT_174] = [__v_64];
-                    record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_177] = [__v_64];
+                    record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
@@ -19901,28 +19344,28 @@ fn aiur_fn_174(
 }
  };
                     let __v_64: G = __mc_out___mc_1[0];
-                    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_13]; 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_65: G = __r_arr[0];
-                    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_60, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_60, __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_66: G = __r_arr[0];
-                    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_60, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_60, __v_5]; 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_67: G = __r_arr[0];
-                    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_58, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_58, __v_3]; 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_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_156] = { let __args: [G; IN_156] = [__v_13, __v_66, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_13, __v_66, __v_70]; 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_71: G = __r_arr[0];
                     let __v_72: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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[171].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[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_73: G = __r_arr[0];
                     let __v_74: G = (__v_7 + __v_65);
-                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[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_75: G = __r_arr[0];
-                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
                     let __v_76: G = __r_arr[0];
-                    let __ret: [G; OUT_174] = [__v_76];
-                    record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_177] = [__v_76];
+                    record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -19931,35 +19374,35 @@ fn aiur_fn_174(
                 }
               },
               6u64 => {
-                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[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_62: G = __r_arr[0];
-                let __ret: [G; OUT_174] = [__v_62];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_177] = [__v_62];
+                record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               4u64 => {
-                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[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_62: G = __r_arr[0];
-                let __ret: [G; OUT_174] = [__v_62];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_177] = [__v_62];
+                record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               5u64 => {
-                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[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_62: G = __r_arr[0];
-                let __ret: [G; OUT_174] = [__v_62];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_177] = [__v_62];
+                record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               7u64 => {
-                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[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_62: G = __r_arr[0];
-                let __ret: [G; OUT_174] = [__v_62];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_177] = [__v_62];
+                record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_58, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_58, __v_3]; 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_62: G = __r_arr[0];
                 let __v_63: G = __r_arr[1];
                 let __v_64: G = G::from_u64(0);
@@ -19967,7 +19410,7 @@ fn aiur_fn_174(
                 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_127] = { let __args: [G; IN_127] = [__v_60]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_60]; let __cu = true; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { 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_69: G = __r_arr[0];
                 let __v_70: G = G::from_u64(0);
                 let __v_71: G = G::from_u64(0);
@@ -19975,15 +19418,15 @@ fn aiur_fn_174(
                 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_174] = { let __args: [G; IN_174] = [__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[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[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_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_174] = [__v_77];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_177] = [__v_77];
+                record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               2u64 => {
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_58, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_58, __v_3]; 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_62: G = __r_arr[0];
                 let __v_63: G = __r_arr[1];
                 let __v_64: G = G::from_u64(1);
@@ -19995,15 +19438,15 @@ fn aiur_fn_174(
                 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_174] = { let __args: [G; IN_174] = [__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[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[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_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_174] = [__v_74];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_177] = [__v_74];
+                record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               3u64 => {
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_58, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_58, __v_3]; 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_62: G = __r_arr[0];
                 let __v_63: G = __r_arr[1];
                 let __v_64: G = G::from_u64(1);
@@ -20015,18 +19458,18 @@ fn aiur_fn_174(
                 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_174] = { let __args: [G; IN_174] = [__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[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[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_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_174] = [__v_74];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_177] = [__v_74];
+                record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_58, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_58, __v_3]; 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_62: G = __r_arr[0];
                 let __v_63: G = __r_arr[1];
-                let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[166].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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_64: G = __r_arr[0];
                 let __v_65: G = __r_arr[1];
                 let __v_66: G = G::from_u64(0);
@@ -20039,11 +19482,11 @@ fn aiur_fn_174(
                 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_174] = { let __args: [G; IN_174] = [__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[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[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_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_174] = [__v_77];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_177] = [__v_77];
+                record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -20060,15 +19503,15 @@ fn aiur_fn_174(
   })
 }
 
-const INPUT_SIZE_175: usize = 10;
-const IN_175: usize = 10;
-const OUT_175: usize = 2;
-fn aiur_fn_175(
-  inp: [G; IN_175],
+const INPUT_SIZE_178: usize = 10;
+const IN_178: usize = 10;
+const OUT_178: usize = 2;
+fn aiur_fn_178(
+  inp: [G; IN_178],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_175], ExecError> {
+) -> Result<[G; OUT_178], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20081,7 +19524,7 @@ fn aiur_fn_175(
     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_763] = { let __args: [G; IN_763] = [__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[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__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[766].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     match __v_11.as_canonical_u64() {
       1u64 => {
@@ -20091,16 +19534,16 @@ fn aiur_fn_175(
         let __v_14: G = __loaded[2];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_175] = [__v_2, __v_3];
-            record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_178] = [__v_2, __v_3];
+            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__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[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__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[178].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
-            let __ret: [G; OUT_175] = [__v_15, __v_16];
-            record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_178] = [__v_15, __v_16];
+            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -20171,16 +19614,16 @@ fn aiur_fn_175(
             let __v_55: G = __loaded[2];
             match __v_53.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_175] = [__v_2, __v_3];
-                record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_178] = [__v_2, __v_3];
+                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__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[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__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[178].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
                 let __v_56: G = __r_arr[0];
                 let __v_57: G = __r_arr[1];
-                let __ret: [G; OUT_175] = [__v_56, __v_57];
-                record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_178] = [__v_56, __v_57];
+                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -20192,14 +19635,14 @@ fn aiur_fn_175(
             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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
             let __v_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_123] = { let __args: [G; IN_123] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0]; 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_62: G = __r_arr[0];
             let __v_63: G = __r_arr[1];
             let __v_64: G = __r_arr[2];
@@ -20253,7 +19696,7 @@ fn aiur_fn_175(
             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_129] = { let __args: [G; IN_129] = [__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[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__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[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_113: G = __r_arr[0];
                 let __v_114: G = G::from_u64(0);
                 let __v_115: G = G::from_u64(0);
@@ -20288,16 +19731,16 @@ fn aiur_fn_175(
                 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_126] = { let __args: [G; IN_126] = [__v_113, __v_146]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_113, __v_146]; 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_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_762] = { let __args: [G; IN_762] = [__v_108, __v_150]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_108, __v_150]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
                     let __v_151: G = __r_arr[0];
-                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_151, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_151, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
                     let __v_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];
@@ -20305,16 +19748,16 @@ fn aiur_fn_175(
                     let __v_155: G = __loaded[2];
                     match __v_153.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_175] = [__v_54, __v_112];
-                        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_178] = [__v_54, __v_112];
+                        record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__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[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__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[178].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
                         let __v_156: G = __r_arr[0];
                         let __v_157: G = __r_arr[1];
-                        let __ret: [G; OUT_175] = [__v_156, __v_157];
-                        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_178] = [__v_156, __v_157];
+                        record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -20328,9 +19771,9 @@ fn aiur_fn_175(
                     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_762] = { let __args: [G; IN_762] = [__v_108, __v_152]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_108, __v_152]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
                     let __v_153: G = __r_arr[0];
-                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_153, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_153, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
                     let __v_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];
@@ -20338,16 +19781,16 @@ fn aiur_fn_175(
                     let __v_157: G = __loaded[2];
                     match __v_155.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_175] = [__v_54, __v_112];
-                        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_178] = [__v_54, __v_112];
+                        record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__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[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__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[178].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
                         let __v_158: G = __r_arr[0];
                         let __v_159: G = __r_arr[1];
-                        let __ret: [G; OUT_175] = [__v_158, __v_159];
-                        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_178] = [__v_158, __v_159];
+                        record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -20368,15 +19811,15 @@ fn aiur_fn_175(
   })
 }
 
-const INPUT_SIZE_176: usize = 1;
-const IN_176: usize = 1;
-const OUT_176: usize = 1;
-fn aiur_fn_176(
-  inp: [G; IN_176],
+const INPUT_SIZE_179: usize = 1;
+const IN_179: usize = 1;
+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_176], ExecError> {
+) -> Result<[G; OUT_179], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(1);
@@ -20390,15 +19833,15 @@ fn aiur_fn_176(
     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_175] = { let __args: [G; IN_175] = [__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[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__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[178].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
     let __v_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_144] = { let __args: [G; IN_144] = [__v_13, __v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_13, __v_12, __v_14]; 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_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
     let __v_17: G = __r_arr[2];
-    let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_15, __v_16]; 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_18: G = __r_arr[0];
     let __v_19: G = __r_arr[1];
     let __v_20: G = __r_arr[2];
@@ -20407,11 +19850,11 @@ fn aiur_fn_176(
     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_146] = { let __args: [G; IN_146] = [__v_13, __v_12, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_13, __v_12, __v_24, __v_25]; 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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_13, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_13, __v_26]; 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_27: G = __r_arr[0];
-    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_12, __v_13]; 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_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
     let __v_30: G = __r_arr[2];
@@ -20420,25 +19863,25 @@ fn aiur_fn_176(
     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_173] = { let __args: [G; IN_173] = [__v_13, __v_12, __v_12, __v_27, __v_34, __v_24, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_13, __v_12, __v_12, __v_27, __v_34, __v_24, __v_35]; 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_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_36]; 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_37: G = __r_arr[0];
-    let __ret: [G; OUT_176] = [__v_37];
-    record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_179] = [__v_37];
+    record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_177: usize = 5;
-const IN_177: usize = 5;
-const OUT_177: usize = 1;
-fn aiur_fn_177(
-  inp: [G; IN_177],
+const INPUT_SIZE_180: usize = 5;
+const IN_180: usize = 5;
+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_177], ExecError> {
+) -> Result<[G; OUT_180], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20451,36 +19894,36 @@ fn aiur_fn_177(
         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_177] = [__v_8];
-        record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_180] = [__v_8];
+        record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_2, __v_3, __v_4]; 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 = 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_177] = { let __args: [G; IN_177] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
         let __v_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_177] = [__v_11];
-        record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_180] = [__v_11];
+        record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_178: usize = 1;
-const IN_178: usize = 1;
-const OUT_178: usize = 1;
-fn aiur_fn_178(
-  inp: [G; IN_178],
+const INPUT_SIZE_181: usize = 1;
+const IN_181: usize = 1;
+const OUT_181: usize = 1;
+fn aiur_fn_181(
+  inp: [G; IN_181],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_178], ExecError> {
+) -> Result<[G; OUT_181], 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 };
@@ -20537,32 +19980,32 @@ fn aiur_fn_178(
         match __v_1.as_canonical_u64() {
           6u64 => {
             let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_178] = [__v_49];
-            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_181] = [__v_49];
+            record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_178] = [__v_49];
-            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_181] = [__v_49];
+            record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
             let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_178] = [__v_49];
-            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_181] = [__v_49];
+            record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           7u64 => {
             let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_178] = [__v_49];
-            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_181] = [__v_49];
+            record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_49: G = G::from_u64(0);
-            let __ret: [G; OUT_178] = [__v_49];
-            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_181] = [__v_49];
+            record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -20571,15 +20014,15 @@ fn aiur_fn_178(
   })
 }
 
-const INPUT_SIZE_179: usize = 4;
-const IN_179: usize = 4;
-const OUT_179: usize = 2;
-fn aiur_fn_179(
-  inp: [G; IN_179],
+const INPUT_SIZE_182: usize = 4;
+const IN_182: usize = 4;
+const OUT_182: usize = 2;
+fn aiur_fn_182(
+  inp: [G; IN_182],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_179], ExecError> {
+) -> Result<[G; OUT_182], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20625,8 +20068,8 @@ fn aiur_fn_179(
         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_179] = [__v_7, __v_40];
-        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_182] = [__v_7, __v_40];
+        record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -20644,22 +20087,22 @@ fn aiur_fn_179(
               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_178] = { let __args: [G; IN_178] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_8]; 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_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_179] = [__v_17, __v_5];
-                    record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_182] = [__v_17, __v_5];
+                    record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_6, __v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_6, __v_9, __v_12]; 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_17: G = __r_arr[0];
                     let __v_18: G = __r_arr[1];
-                    let __ret: [G; OUT_179] = [__v_17, __v_18];
-                    record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_182] = [__v_17, __v_18];
+                    record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -20681,15 +20124,15 @@ fn aiur_fn_179(
   })
 }
 
-const INPUT_SIZE_180: usize = 3;
-const IN_180: usize = 3;
-const OUT_180: usize = 1;
-fn aiur_fn_180(
-  inp: [G; IN_180],
+const INPUT_SIZE_183: usize = 3;
+const IN_183: usize = 3;
+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_180], ExecError> {
+) -> Result<[G; OUT_183], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20733,8 +20176,8 @@ fn aiur_fn_180(
         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_180] = [__v_38];
-        record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_183] = [__v_38];
+        record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -20747,15 +20190,15 @@ fn aiur_fn_180(
             let __v_9: G = (__v_7 - __v_0);
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_180] = [__v_4];
-                record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_183] = [__v_4];
+                record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_5, __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 __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_5, __v_8]; 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_10: G = __r_arr[0];
-                let __ret: [G; OUT_180] = [__v_10];
-                record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_183] = [__v_10];
+                record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -20772,34 +20215,34 @@ fn aiur_fn_180(
   })
 }
 
-const INPUT_SIZE_181: usize = 4;
-const IN_181: usize = 4;
-const OUT_181: usize = 1;
-fn aiur_fn_181(
-  inp: [G; IN_181],
+const INPUT_SIZE_184: usize = 4;
+const IN_184: usize = 4;
+const OUT_184: usize = 1;
+fn aiur_fn_184(
+  inp: [G; IN_184],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_181], ExecError> {
+) -> Result<[G; OUT_184], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2, __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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_181] = [__v_5];
-        record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_184] = [__v_5];
+        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_3]; 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 __ret: [G; OUT_181] = [__v_6];
-        record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_184] = [__v_6];
+        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -20809,15 +20252,15 @@ fn aiur_fn_181(
   })
 }
 
-const INPUT_SIZE_182: usize = 10;
-const IN_182: usize = 10;
-const OUT_182: usize = 6;
-fn aiur_fn_182(
-  inp: [G; IN_182],
+const INPUT_SIZE_185: usize = 10;
+const IN_185: usize = 10;
+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_182], ExecError> {
+) -> Result<[G; OUT_185], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20835,8 +20278,8 @@ fn aiur_fn_182(
     let __v_12: G = __loaded[2];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_182] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
-        record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_185] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
+        record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -20852,39 +20295,39 @@ fn aiur_fn_182(
             let __v_18: G = __loaded[2];
             match __v_16.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_14]; 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_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_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
                     let __v_21: G = __r_arr[0];
                     let __v_22: G = __r_arr[1];
                     let __v_23: G = __r_arr[2];
                     let __v_24: G = __r_arr[3];
                     let __v_25: G = __r_arr[4];
                     let __v_26: G = __r_arr[5];
-                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__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[182].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__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[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_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_182] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
-                    record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_185] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
+                    record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__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[182].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__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[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_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_182] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-                    record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_185] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+                    record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -20906,15 +20349,15 @@ fn aiur_fn_182(
   })
 }
 
-const INPUT_SIZE_183: usize = 3;
-const IN_183: usize = 3;
-const OUT_183: usize = 6;
-fn aiur_fn_183(
-  inp: [G; IN_183],
+const INPUT_SIZE_186: usize = 3;
+const IN_186: usize = 3;
+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_183], ExecError> {
+) -> Result<[G; OUT_186], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20922,7 +20365,7 @@ fn aiur_fn_183(
     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_182] = { let __args: [G; IN_182] = [__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[182].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__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[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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     let __v_8: G = __r_arr[2];
@@ -20930,28 +20373,28 @@ fn aiur_fn_183(
     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_182] = { let __args: [G; IN_182] = [__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[182].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__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[185].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
     let __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_183] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
-    record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_186] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
+    record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_184: usize = 7;
-const IN_184: usize = 7;
-const OUT_184: usize = 6;
-fn aiur_fn_184(
-  inp: [G; IN_184],
+const INPUT_SIZE_187: usize = 7;
+const IN_187: usize = 7;
+const OUT_187: usize = 6;
+fn aiur_fn_187(
+  inp: [G; IN_187],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_184], ExecError> {
+) -> Result<[G; OUT_187], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20967,27 +20410,27 @@ fn aiur_fn_184(
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_184] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_187] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
+        record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
         let __v_14: G = __r_arr[3];
         let __v_15: G = __r_arr[4];
         let __v_16: G = __r_arr[5];
-        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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_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_184] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_187] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
+        record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -20997,15 +20440,15 @@ fn aiur_fn_184(
   })
 }
 
-const INPUT_SIZE_185: usize = 9;
-const IN_185: usize = 9;
-const OUT_185: usize = 1;
-fn aiur_fn_185(
-  inp: [G; IN_185],
+const INPUT_SIZE_188: usize = 9;
+const IN_188: usize = 9;
+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_185], ExecError> {
+) -> Result<[G; OUT_188], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21022,36 +20465,36 @@ fn aiur_fn_185(
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 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_185] = [__v_12];
-        record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_188] = [__v_12];
+        record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__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[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__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[766].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(1);
         let __v_13: G = (__v_0 + __v_12);
-        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__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[185].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__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[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_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_185] = [__v_15];
-        record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_188] = [__v_15];
+        record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_186: usize = 3;
-const IN_186: usize = 3;
-const OUT_186: usize = 1;
-fn aiur_fn_186(
-  inp: [G; IN_186],
+const INPUT_SIZE_189: usize = 3;
+const IN_189: usize = 3;
+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_186], ExecError> {
+) -> Result<[G; OUT_189], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21065,8 +20508,8 @@ fn aiur_fn_186(
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_186] = [__v_8];
-        record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_189] = [__v_8];
+        record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -21131,9 +20574,9 @@ fn aiur_fn_186(
                   6u64 => {
                     match __v_7.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_15, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_15, __v_2]; 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_57: G = __r_arr[0];
-                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_15]; 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_58: G = __r_arr[0];
                         let __v_59: G = __r_arr[1];
                         let __v_60: G = __r_arr[2];
@@ -21186,33 +20629,33 @@ fn aiur_fn_186(
                           _ => {
                             match __v_58.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                                 let __v_106: G = __r_arr[0];
-                                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_59, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_59, __v_106]; 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_107: G = __r_arr[0];
                                 let __v_108: G = G::from_u64(1);
                                 let __v_109: G = (__v_107 + __v_108);
                                 let __v_110: G = (__v_57 + __v_109);
-                                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                                 let __v_111: G = __r_arr[0];
-                                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_59, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_59, __v_111]; 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_112: G = __r_arr[0];
                                 let __v_113: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__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[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__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[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_114: G = __r_arr[0];
-                                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_56, __v_2]; 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 __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_5, __v_56, __v_2]; 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_115: G = __r_arr[0];
-                                let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_114, __v_115]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_114, __v_115]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } else { aiur_fn_779(__args, record, io_buffer, __cu)? } };
                                 let __v_116: G = __r_arr[0];
-                                let __ret: [G; OUT_186] = [__v_116];
-                                record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_189] = [__v_116];
+                                record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_56, __v_2]; 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 __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_5, __v_56, __v_2]; 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_106: G = __r_arr[0];
-                                let __ret: [G; OUT_186] = [__v_106];
-                                record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_189] = [__v_106];
+                                record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -21222,10 +20665,10 @@ fn aiur_fn_186(
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_56, __v_2]; 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 __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_5, __v_56, __v_2]; 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_57: G = __r_arr[0];
-                    let __ret: [G; OUT_186] = [__v_57];
-                    record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_189] = [__v_57];
+                    record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -21244,36 +20687,36 @@ fn aiur_fn_186(
   })
 }
 
-const INPUT_SIZE_187: usize = 2;
-const IN_187: usize = 2;
-const OUT_187: usize = 1;
-fn aiur_fn_187(
-  inp: [G; IN_187],
+const INPUT_SIZE_190: usize = 2;
+const IN_190: usize = 2;
+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_187], ExecError> {
+) -> Result<[G; OUT_190], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_0, __v_1, __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 __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0];
-    let __ret: [G; OUT_187] = [__v_3];
-    record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_190] = [__v_3];
+    record.function_queries[190].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],
+const INPUT_SIZE_191: usize = 3;
+const IN_191: usize = 3;
+const OUT_191: usize = 1;
+fn aiur_fn_191(
+  inp: [G; IN_191],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_188], ExecError> {
+) -> Result<[G; OUT_191], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21329,8 +20772,8 @@ fn aiur_fn_188(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_50: G = G::from_u64(0);
-        let __ret: [G; OUT_188] = [__v_50];
-        record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_191] = [__v_50];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -21341,18 +20784,18 @@ fn aiur_fn_188(
               1u64 => {
                 match __v_5.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } else { aiur_fn_782(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
                     let __v_51: G = __r_arr[0];
-                    let __ret: [G; OUT_188] = [__v_51];
-                    record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_191] = [__v_51];
+                    record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_51: G = G::from_u64(0);
-                let __ret: [G; OUT_188] = [__v_51];
-                record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_191] = [__v_51];
+                record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -21360,10 +20803,10 @@ fn aiur_fn_188(
           _ => {
             let __v_51: G = G::from_u64(1);
             let __v_52: G = (__v_2 + __v_51);
-            let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_49, __v_1, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_49, __v_1, __v_52]; 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_53: G = __r_arr[0];
-            let __ret: [G; OUT_188] = [__v_53];
-            record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_191] = [__v_53];
+            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -21375,15 +20818,15 @@ fn aiur_fn_188(
   })
 }
 
-const INPUT_SIZE_189: usize = 12;
-const IN_189: usize = 12;
-const OUT_189: usize = 1;
-fn aiur_fn_189(
-  inp: [G; IN_189],
+const INPUT_SIZE_192: usize = 12;
+const IN_192: usize = 12;
+const OUT_192: usize = 1;
+fn aiur_fn_192(
+  inp: [G; IN_192],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_189], ExecError> {
+) -> Result<[G; OUT_192], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21403,37 +20846,37 @@ fn aiur_fn_189(
         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_189] = [__v_15];
-        record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_192] = [__v_15];
+        record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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[190].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __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_189] = { let __args: [G; IN_189] = [__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[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__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[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_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_189] = [__v_19];
-        record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_192] = [__v_19];
+        record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_190: usize = 10;
-const IN_190: usize = 10;
-const OUT_190: usize = 1;
-fn aiur_fn_190(
-  inp: [G; IN_190],
+const INPUT_SIZE_193: usize = 10;
+const IN_193: usize = 10;
+const OUT_193: usize = 1;
+fn aiur_fn_193(
+  inp: [G; IN_193],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_190], ExecError> {
+) -> Result<[G; OUT_193], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21466,25 +20909,25 @@ fn aiur_fn_190(
     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_69] = { let __args: [G; IN_69] = [__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[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 __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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[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 __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_31]; 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_32: G = __r_arr[0];
-    let __ret: [G; OUT_190] = [__v_32];
-    record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_193] = [__v_32];
+    record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_191: usize = 1;
-const IN_191: usize = 1;
-const OUT_191: usize = 2;
-fn aiur_fn_191(
-  inp: [G; IN_191],
+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_191], ExecError> {
+) -> Result<[G; OUT_194], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(1);
@@ -21498,27 +20941,27 @@ fn aiur_fn_191(
     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_175] = { let __args: [G; IN_175] = [__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[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__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[178].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
-    let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_12, __v_13]; 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_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
-    let __ret: [G; OUT_191] = [__v_14, __v_15];
-    record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_194] = [__v_14, __v_15];
+    record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_192: usize = 1;
-const IN_192: usize = 1;
-const OUT_192: usize = 2;
-fn aiur_fn_192(
-  inp: [G; IN_192],
+const INPUT_SIZE_195: usize = 1;
+const IN_195: usize = 1;
+const OUT_195: usize = 2;
+fn aiur_fn_195(
+  inp: [G; IN_195],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_192], ExecError> {
+) -> Result<[G; OUT_195], 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 };
@@ -21527,11 +20970,11 @@ fn aiur_fn_192(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; 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_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
-        let __ret: [G; OUT_192] = [__v_4, __v_5];
-        record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_195] = [__v_4, __v_5];
+        record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -21543,14 +20986,14 @@ fn aiur_fn_192(
         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_175] = { let __args: [G; IN_175] = [__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[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__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[178].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_12, __v_13]; 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __ret: [G; OUT_192] = [__v_14, __v_15];
-        record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_195] = [__v_14, __v_15];
+        record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -21560,24 +21003,24 @@ fn aiur_fn_192(
   })
 }
 
-const INPUT_SIZE_193: usize = 2;
-const IN_193: usize = 2;
-const OUT_193: usize = 2;
-fn aiur_fn_193(
-  inp: [G; IN_193],
+const INPUT_SIZE_196: usize = 2;
+const IN_196: usize = 2;
+const OUT_196: usize = 2;
+fn aiur_fn_196(
+  inp: [G; IN_196],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_193], ExecError> {
+) -> Result<[G; OUT_196], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_0, __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 __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1, __v_0, __v_2]; 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
-    let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_3, __v_4]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     let __v_8: G = __r_arr[2];
@@ -21586,11 +21029,11 @@ fn aiur_fn_193(
     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_146] = { let __args: [G; IN_146] = [__v_1, __v_0, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_1, __v_0, __v_12, __v_13]; 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_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_1, __v_14]; 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_0, __v_1]; 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_16: G = __r_arr[0];
     let __v_17: G = __r_arr[1];
     let __v_18: G = __r_arr[2];
@@ -21599,20 +21042,20 @@ fn aiur_fn_193(
     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_173] = { let __args: [G; IN_173] = [__v_1, __v_0, __v_0, __v_15, __v_22, __v_12, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_1, __v_0, __v_0, __v_15, __v_22, __v_12, __v_23]; 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_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_24]; 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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_15]; 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 __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_1, __v_15]; 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_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_186] = { let __args: [G; IN_186] = [__v_1, __v_0, __v_12]; 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 __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_1, __v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
     let __v_32: G = __r_arr[0];
-    let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_32, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_32, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; 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_33: G = __r_arr[0];
     let __v_34: G = __r_arr[1];
     let __v_35: G = __r_arr[2];
@@ -21653,32 +21096,32 @@ fn aiur_fn_193(
     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_185] = { let __args: [G; IN_185] = [__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[185].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__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[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_73: G = __r_arr[0];
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; 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_74: G = __r_arr[0];
     let __v_75: G = __r_arr[1];
-    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_25, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_25, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
     let __v_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
     let __v_77: G = __r_arr[0];
-    let __ret: [G; OUT_193] = [__v_76, __v_77];
-    record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_196] = [__v_76, __v_77];
+    record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_194: usize = 0;
-const IN_194: usize = 0;
-const OUT_194: usize = 2;
-fn aiur_fn_194(
-  inp: [G; IN_194],
+const INPUT_SIZE_197: usize = 0;
+const IN_197: usize = 0;
+const OUT_197: usize = 2;
+fn aiur_fn_197(
+  inp: [G; IN_197],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_194], ExecError> {
+) -> Result<[G; OUT_197], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = []; 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_0: G = __r_arr[0];
     let __v_1: G = G::from_u64(1);
     let __v_2: G = G::from_u64(0);
@@ -21691,232 +21134,232 @@ fn aiur_fn_194(
     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_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_11, __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_13: G = __r_arr[0];
-    let __ret: [G; OUT_194] = [__v_13, __v_0];
-    record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_197] = [__v_13, __v_0];
+    record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_195: usize = 0;
-const IN_195: usize = 0;
-const OUT_195: usize = 1;
-fn aiur_fn_195(
-  inp: [G; IN_195],
+const INPUT_SIZE_198: usize = 0;
+const IN_198: usize = 0;
+const OUT_198: usize = 1;
+fn aiur_fn_198(
+  inp: [G; IN_198],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_195], ExecError> {
+) -> Result<[G; OUT_198], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(0);
-    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = []; 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 __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_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = []; 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 __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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } else { aiur_fn_238(__args, record, io_buffer, __cu)? } };
+    let __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_5: G = __r_arr[0];
     let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+    let __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_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(0);
-    let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__args, record, io_buffer, __cu)? } };
+    let __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_9: G = __r_arr[0];
     let __v_10: G = G::from_u64(0);
-    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+    let __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_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+    let __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_13: G = __r_arr[0];
     let __v_14: G = G::from_u64(0);
-    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+    let __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_15: G = __r_arr[0];
     let __v_16: G = G::from_u64(0);
-    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+    let __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_17: G = __r_arr[0];
     let __v_18: G = G::from_u64(0);
-    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+    let __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_19: G = __r_arr[0];
     let __v_20: G = G::from_u64(0);
-    let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+    let __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_21: G = __r_arr[0];
     let __v_22: G = G::from_u64(0);
-    let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
+    let __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_23: G = __r_arr[0];
     let __v_24: G = G::from_u64(0);
-    let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
+    let __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_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 __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_27: G = __r_arr[0];
     let __v_28: G = G::from_u64(0);
-    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } };
+    let __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_29: G = __r_arr[0];
     let __v_30: G = G::from_u64(0);
-    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+    let __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_31: G = __r_arr[0];
     let __v_32: G = G::from_u64(0);
-    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } };
+    let __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_33: G = __r_arr[0];
     let __v_34: G = G::from_u64(0);
-    let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } };
+    let __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_35: G = __r_arr[0];
     let __v_36: G = G::from_u64(0);
-    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+    let __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_37: G = __r_arr[0];
     let __v_38: G = G::from_u64(0);
-    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
+    let __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_39: G = __r_arr[0];
     let __v_40: G = G::from_u64(0);
-    let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } };
+    let __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_41: G = __r_arr[0];
     let __v_42: G = G::from_u64(0);
-    let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } };
+    let __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_43: G = __r_arr[0];
     let __v_44: G = G::from_u64(0);
-    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __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_45: G = __r_arr[0];
     let __v_46: G = G::from_u64(0);
-    let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } };
+    let __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_47: G = __r_arr[0];
     let __v_48: G = G::from_u64(0);
-    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
+    let __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_49: G = __r_arr[0];
     let __v_50: G = G::from_u64(0);
-    let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+    let __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_51: G = __r_arr[0];
     let __v_52: G = G::from_u64(0);
-    let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } };
+    let __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];
     let __v_54: G = G::from_u64(0);
-    let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+    let __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_55: G = __r_arr[0];
     let __v_56: G = G::from_u64(0);
-    let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__args, record, io_buffer, __cu)? } };
+    let __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_57: G = __r_arr[0];
     let __v_58: G = G::from_u64(0);
-    let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__args, record, io_buffer, __cu)? } };
+    let __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_59: G = __r_arr[0];
     let __v_60: G = G::from_u64(0);
-    let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+    let __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_61: G = __r_arr[0];
     let __v_62: G = G::from_u64(0);
-    let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+    let __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_63: G = __r_arr[0];
     let __v_64: G = G::from_u64(0);
-    let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+    let __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_65: G = __r_arr[0];
     let __v_66: G = G::from_u64(0);
-    let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+    let __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_67: G = __r_arr[0];
     let __v_68: G = G::from_u64(0);
-    let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
+    let __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_69: G = __r_arr[0];
     let __v_70: G = G::from_u64(0);
-    let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+    let __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_71: G = __r_arr[0];
     let __v_72: G = G::from_u64(0);
-    let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
+    let __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_73: G = __r_arr[0];
     let __v_74: G = G::from_u64(0);
-    let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
+    let __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_75: G = __r_arr[0];
     let __v_76: G = G::from_u64(0);
-    let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
+    let __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_77: G = __r_arr[0];
     let __v_78: G = G::from_u64(0);
-    let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
+    let __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_79: G = __r_arr[0];
     let __v_80: G = G::from_u64(0);
-    let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
+    let __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_81: G = __r_arr[0];
     let __v_82: G = G::from_u64(0);
-    let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
+    let __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_83: G = __r_arr[0];
     let __v_84: G = G::from_u64(0);
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __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_85: G = __r_arr[0];
     let __v_86: G = G::from_u64(0);
-    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
+    let __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_87: G = __r_arr[0];
     let __v_88: G = G::from_u64(0);
-    let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+    let __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_89: G = __r_arr[0];
     let __v_90: G = G::from_u64(0);
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __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_91: G = __r_arr[0];
     let __v_92: G = G::from_u64(0);
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __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_93: G = __r_arr[0];
     let __v_94: G = G::from_u64(0);
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __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_95: G = __r_arr[0];
     let __v_96: G = G::from_u64(0);
-    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
+    let __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_97: G = __r_arr[0];
     let __v_98: G = G::from_u64(0);
-    let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+    let __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_99: G = __r_arr[0];
     let __v_100: G = G::from_u64(0);
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __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_101: G = __r_arr[0];
     let __v_102: G = G::from_u64(0);
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __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_103: G = __r_arr[0];
     let __v_104: G = G::from_u64(0);
-    let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+    let __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_105: G = __r_arr[0];
     let __v_106: G = G::from_u64(0);
-    let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+    let __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_107: G = __r_arr[0];
     let __v_108: G = G::from_u64(0);
-    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+    let __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_109: G = __r_arr[0];
     let __v_110: G = G::from_u64(0);
-    let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+    let __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_111: G = __r_arr[0];
     let __v_112: G = G::from_u64(0);
-    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+    let __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_113: G = __r_arr[0];
     let __v_114: G = G::from_u64(0);
-    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+    let __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_115: G = __r_arr[0];
     let __v_116: G = G::from_u64(0);
-    let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+    let __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_117: G = __r_arr[0];
     let __v_118: G = G::from_u64(0);
-    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+    let __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_119: G = __r_arr[0];
     let __v_120: G = G::from_u64(0);
-    let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+    let __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_121: G = __r_arr[0];
     let __v_122: G = G::from_u64(0);
-    let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
+    let __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_123: G = __r_arr[0];
     let __v_124: G = G::from_u64(0);
-    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+    let __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_125: G = __r_arr[0];
     let __v_126: G = G::from_u64(0);
-    let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
+    let __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_127: G = __r_arr[0];
     let __v_128: G = G::from_u64(0);
-    let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
+    let __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_129: G = __r_arr[0];
     let __v_130: G = G::from_u64(0);
-    let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
+    let __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_131: G = __r_arr[0];
     let __v_132: G = G::from_u64(0);
-    let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
+    let __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_133: G = __r_arr[0];
     let __v_134: G = G::from_u64(0);
-    let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+    let __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_135: G = __r_arr[0];
     let __v_136: G = G::from_u64(0);
-    let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = []; 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_137: G = __r_arr[0];
     let __v_138: G = G::from_u64(1);
     let __v_139: G = G::from_u64(1);
@@ -21990,21 +21433,21 @@ fn aiur_fn_195(
     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_195] = [__v_209];
-    record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_198] = [__v_209];
+    record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_196: usize = 1;
-const IN_196: usize = 1;
-const OUT_196: usize = 1;
-fn aiur_fn_196(
-  inp: [G; IN_196],
+const INPUT_SIZE_199: usize = 1;
+const IN_199: usize = 1;
+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_196], ExecError> {
+) -> Result<[G; OUT_199], 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 };
@@ -22014,17 +21457,17 @@ fn aiur_fn_196(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_196] = [__v_4];
-        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_199] = [__v_4];
+        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
         let __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_196] = [__v_6];
-        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_199] = [__v_6];
+        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -22034,15 +21477,15 @@ fn aiur_fn_196(
   })
 }
 
-const INPUT_SIZE_197: usize = 2;
-const IN_197: usize = 2;
-const OUT_197: usize = 1;
-fn aiur_fn_197(
-  inp: [G; IN_197],
+const INPUT_SIZE_200: usize = 2;
+const IN_200: usize = 2;
+const OUT_200: usize = 1;
+fn aiur_fn_200(
+  inp: [G; IN_200],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_197], ExecError> {
+) -> Result<[G; OUT_200], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22051,34 +21494,34 @@ fn aiur_fn_197(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __v_4: G = { let __values: [G; 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_197] = [__v_4];
-        record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_200] = [__v_4];
+        record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         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_197] = { let __args: [G; IN_197] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __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 = { 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_197] = [__v_6];
-        record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_200] = [__v_6];
+        record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_198: usize = 1;
-const IN_198: usize = 1;
-const OUT_198: usize = 2;
-fn aiur_fn_198(
-  inp: [G; IN_198],
+const INPUT_SIZE_201: usize = 1;
+const IN_201: usize = 1;
+const OUT_201: usize = 2;
+fn aiur_fn_201(
+  inp: [G; IN_201],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_198], ExecError> {
+) -> Result<[G; OUT_201], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -22088,36 +21531,36 @@ fn aiur_fn_198(
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       3u64 => {
-        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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_198] = [__v_5, __v_7];
-        record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_201] = [__v_5, __v_7];
+        record.function_queries[201].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_198] = [__v_0, __v_7];
-        record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_201] = [__v_0, __v_7];
+        record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_199: usize = 1;
-const IN_199: usize = 1;
-const OUT_199: usize = 1;
-fn aiur_fn_199(
-  inp: [G; IN_199],
+const INPUT_SIZE_202: usize = 1;
+const IN_202: usize = 1;
+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_199], ExecError> {
+) -> Result<[G; OUT_202], 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 };
@@ -22127,57 +21570,57 @@ fn aiur_fn_199(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_199] = [__v_4];
-        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_202] = [__v_4];
+        record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_199] = [__v_4];
-        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_202] = [__v_4];
+        record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_199] = [__v_4];
-        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_202] = [__v_4];
+        record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_2]; 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           0u64 => {
             match __v_5.as_canonical_u64() {
               0u64 => {
                 let __v_6: G = G::from_u64(0);
-                let __ret: [G; OUT_199] = [__v_6];
-                record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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(1);
-                let __ret: [G; OUT_199] = [__v_6];
-                record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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(1);
-            let __ret: [G; OUT_199] = [__v_6];
-            record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_202] = [__v_6];
+            record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_199] = [__v_4];
-        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_202] = [__v_4];
+        record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -22187,15 +21630,15 @@ fn aiur_fn_199(
   })
 }
 
-const INPUT_SIZE_200: usize = 2;
-const IN_200: usize = 2;
-const OUT_200: usize = 1;
-fn aiur_fn_200(
-  inp: [G; IN_200],
+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_200], ExecError> {
+) -> Result<[G; OUT_203], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22212,14 +21655,14 @@ fn aiur_fn_200(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_203] = [__v_8];
+            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_203] = [__v_8];
+            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -22231,16 +21674,16 @@ fn aiur_fn_200(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3, __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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_3, __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_8: G = __r_arr[0];
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_203] = [__v_8];
+            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_203] = [__v_8];
+            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -22252,19 +21695,19 @@ fn aiur_fn_200(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3, __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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_3, __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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4, __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 __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_9: G = __r_arr[0];
             let __v_10: G = (__v_8 * __v_9);
-            let __ret: [G; OUT_200] = [__v_10];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_203] = [__v_10];
+            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_203] = [__v_8];
+            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -22276,19 +21719,19 @@ fn aiur_fn_200(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3, __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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_3, __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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4, __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 __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_9: G = __r_arr[0];
             let __v_10: G = (__v_8 * __v_9);
-            let __ret: [G; OUT_200] = [__v_10];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_203] = [__v_10];
+            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_203] = [__v_8];
+            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -22302,14 +21745,14 @@ fn aiur_fn_200(
           4u64 => {
             let __v_8: G = (__v_3 - __v_6);
             let __v_9: G = G::from_bool((__v_8 == G::ZERO));
-            let __ret: [G; OUT_200] = [__v_9];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_203] = [__v_9];
+            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_203] = [__v_8];
+            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -22321,15 +21764,15 @@ fn aiur_fn_200(
   })
 }
 
-const INPUT_SIZE_201: usize = 2;
-const IN_201: usize = 2;
-const OUT_201: usize = 1;
-fn aiur_fn_201(
-  inp: [G; IN_201],
+const INPUT_SIZE_204: usize = 2;
+const IN_204: usize = 2;
+const OUT_204: usize = 1;
+fn aiur_fn_204(
+  inp: [G; IN_204],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_201], ExecError> {
+) -> Result<[G; OUT_204], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22346,14 +21789,14 @@ fn aiur_fn_201(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_201] = [__v_8];
-            record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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 = G::from_u64(1);
-            let __ret: [G; OUT_201] = [__v_8];
-            record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_204] = [__v_8];
+            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -22369,8 +21812,8 @@ fn aiur_fn_201(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_201] = [__v_8];
-            record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_204] = [__v_8];
+            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22378,8 +21821,8 @@ fn aiur_fn_201(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(1);
-                let __ret: [G; OUT_201] = [__v_9];
-                record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_204] = [__v_9];
+                record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -22387,15 +21830,15 @@ fn aiur_fn_201(
                 match __v_9.as_canonical_u64() {
                   1u64 => {
                     let __v_10: G = G::from_u64(2);
-                    let __ret: [G; OUT_201] = [__v_10];
-                    record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_201] = { let __args: [G; IN_201] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_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_201] = [__v_10];
-                    record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_204] = [__v_10];
+                    record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -22420,15 +21863,15 @@ fn aiur_fn_201(
   })
 }
 
-const INPUT_SIZE_202: usize = 2;
-const IN_202: usize = 2;
-const OUT_202: usize = 1;
-fn aiur_fn_202(
-  inp: [G; IN_202],
+const INPUT_SIZE_205: usize = 2;
+const IN_205: usize = 2;
+const OUT_205: usize = 1;
+fn aiur_fn_205(
+  inp: [G; IN_205],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_202], ExecError> {
+) -> Result<[G; OUT_205], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22439,8 +21882,8 @@ fn aiur_fn_202(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_202] = [__v_5];
-        record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_205] = [__v_5];
+        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22451,8 +21894,8 @@ fn aiur_fn_202(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_202] = [__v_8];
-            record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_205] = [__v_8];
+            record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22460,25 +21903,25 @@ fn aiur_fn_202(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 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));
+                let __ret: [G; OUT_205] = [__v_9];
+                record.function_queries[205].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_202] = { let __args: [G; IN_202] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_202] = [__v_10];
-                    record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_205] = [__v_10];
+                    record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_202] = [__v_10];
-                    record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_205] = [__v_10];
+                    record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -22503,15 +21946,15 @@ fn aiur_fn_202(
   })
 }
 
-const INPUT_SIZE_203: usize = 2;
-const IN_203: usize = 2;
-const OUT_203: usize = 1;
-fn aiur_fn_203(
-  inp: [G; IN_203],
+const INPUT_SIZE_206: usize = 2;
+const IN_206: usize = 2;
+const OUT_206: usize = 1;
+fn aiur_fn_206(
+  inp: [G; IN_206],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_203], ExecError> {
+) -> 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];
@@ -22528,14 +21971,14 @@ fn aiur_fn_203(
         match __v_5.as_canonical_u64() {
           1u64 => {
             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));
+            let __ret: [G; OUT_206] = [__v_8];
+            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             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));
+            let __ret: [G; OUT_206] = [__v_8];
+            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -22551,15 +21994,15 @@ fn aiur_fn_203(
         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));
+            let __ret: [G; OUT_206] = [__v_8];
+            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_203] = [__v_8];
-            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_206] = [__v_8];
+            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -22574,15 +22017,15 @@ fn aiur_fn_203(
   })
 }
 
-const INPUT_SIZE_204: usize = 2;
-const IN_204: usize = 2;
-const OUT_204: usize = 2;
-fn aiur_fn_204(
-  inp: [G; IN_204],
+const INPUT_SIZE_207: usize = 2;
+const IN_207: usize = 2;
+const OUT_207: usize = 2;
+fn aiur_fn_207(
+  inp: [G; IN_207],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_204], ExecError> {
+) -> Result<[G; OUT_207], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22598,8 +22041,8 @@ fn aiur_fn_204(
         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_204] = [__v_5, __v_10];
-        record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_207] = [__v_5, __v_10];
+        record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22609,8 +22052,8 @@ fn aiur_fn_204(
             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_204] = [__v_6, __v_8];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_207] = [__v_6, __v_8];
+            record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22618,18 +22061,18 @@ fn aiur_fn_204(
             match __v_6.as_canonical_u64() {
               0u64 => {
                 let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_204] = [__v_7, __v_1];
-                record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_207] = [__v_7, __v_1];
+                record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_4]; 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_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_204] = [__v_7, __v_10];
-                record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_207] = [__v_7, __v_10];
+                record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -22649,15 +22092,15 @@ fn aiur_fn_204(
   })
 }
 
-const INPUT_SIZE_205: usize = 3;
-const IN_205: usize = 3;
-const OUT_205: usize = 1;
-fn aiur_fn_205(
-  inp: [G; IN_205],
+const INPUT_SIZE_208: usize = 3;
+const IN_208: usize = 3;
+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_205], ExecError> {
+) -> Result<[G; OUT_208], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22674,8 +22117,8 @@ fn aiur_fn_205(
         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_205] = [__v_11];
-        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_208] = [__v_11];
+        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22690,8 +22133,8 @@ fn aiur_fn_205(
                 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_205] = [__v_11];
-                record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_208] = [__v_11];
+                record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -22699,11 +22142,11 @@ fn aiur_fn_205(
                 match __v_9.as_canonical_u64() {
                   1u64 => {
                     let __v_10: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_5, __v_1, __v_2]; 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_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_205] = [__v_12];
-                    record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_208] = [__v_12];
+                    record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
@@ -22713,13 +22156,13 @@ fn aiur_fn_205(
                         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_205] = [__v_13];
-                        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_208] = [__v_13];
+                        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __ret: [G; OUT_205] = [__v_0];
-                        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_208] = [__v_0];
+                        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -22746,15 +22189,15 @@ fn aiur_fn_205(
   })
 }
 
-const INPUT_SIZE_206: usize = 2;
-const IN_206: usize = 2;
-const OUT_206: usize = 1;
-fn aiur_fn_206(
-  inp: [G; IN_206],
+const INPUT_SIZE_209: usize = 2;
+const IN_209: usize = 2;
+const OUT_209: usize = 1;
+fn aiur_fn_209(
+  inp: [G; IN_209],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_206], ExecError> {
+) -> Result<[G; OUT_209], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22771,14 +22214,14 @@ fn aiur_fn_206(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_206] = [__v_8];
-            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_209] = [__v_8];
+            record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_206] = [__v_8];
-            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_209] = [__v_8];
+            record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -22794,8 +22237,8 @@ fn aiur_fn_206(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_206] = [__v_8];
-            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_209] = [__v_8];
+            record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22815,24 +22258,24 @@ fn aiur_fn_206(
                         let __v_13: G = (__v_9 - __v_11);
                         match __v_13.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_4, __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_14: G = __r_arr[0];
-                            let __ret: [G; OUT_206] = [__v_14];
-                            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_209] = [__v_14];
+                            record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_14: G = G::from_u64(0);
-                            let __ret: [G; OUT_206] = [__v_14];
-                            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_209] = [__v_14];
+                            record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_13: G = G::from_u64(0);
-                        let __ret: [G; OUT_206] = [__v_13];
-                        record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_209] = [__v_13];
+                        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -22853,15 +22296,15 @@ fn aiur_fn_206(
   })
 }
 
-const INPUT_SIZE_207: usize = 1;
-const IN_207: usize = 1;
-const OUT_207: usize = 1;
-fn aiur_fn_207(
-  inp: [G; IN_207],
+const INPUT_SIZE_210: usize = 1;
+const IN_210: usize = 1;
+const OUT_210: usize = 1;
+fn aiur_fn_210(
+  inp: [G; IN_210],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_207], ExecError> {
+) -> Result<[G; OUT_210], 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 };
@@ -22871,8 +22314,8 @@ fn aiur_fn_207(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_207] = [__v_4];
-        record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_210] = [__v_4];
+        record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22881,18 +22324,18 @@ fn aiur_fn_207(
         let __v_5: G = __loaded[1];
         match __v_4.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
             let __v_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_207] = [__v_5];
-                record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_210] = [__v_5];
+                record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __ret: [G; OUT_207] = [__v_6];
-                record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_210] = [__v_6];
+                record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -22909,15 +22352,15 @@ fn aiur_fn_207(
   })
 }
 
-const INPUT_SIZE_208: usize = 2;
-const IN_208: usize = 2;
-const OUT_208: usize = 1;
-fn aiur_fn_208(
-  inp: [G; IN_208],
+const INPUT_SIZE_211: usize = 2;
+const IN_211: usize = 2;
+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_208], ExecError> {
+) -> Result<[G; OUT_211], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22927,8 +22370,8 @@ fn aiur_fn_208(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_208] = [__v_0];
-        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_211] = [__v_0];
+        record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22938,8 +22381,8 @@ fn aiur_fn_208(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_208] = [__v_0];
-            record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_211] = [__v_0];
+            record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22957,21 +22400,21 @@ fn aiur_fn_208(
                     match __v_12.as_canonical_u64() {
                       1u64 => {
                         let __v_13: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_4, __v_1]; 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_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_208] = [__v_15];
-                        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_211] = [__v_15];
+                        record.function_queries[211].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_208] = { let __args: [G; IN_208] = [__v_0, __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 __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __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_14: G = __r_arr[0];
-                            let __ret: [G; OUT_208] = [__v_14];
-                            record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_211] = [__v_14];
+                            record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
@@ -22979,18 +22422,18 @@ fn aiur_fn_208(
                             match __v_14.as_canonical_u64() {
                               1u64 => {
                                 let __v_15: G = G::from_u64(0);
-                                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 __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_4, __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_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_208] = [__v_17];
-                                record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_211] = [__v_17];
+                                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_4, __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_15: G = __r_arr[0];
-                                let __ret: [G; OUT_208] = [__v_15];
-                                record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_211] = [__v_15];
+                                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -23024,23 +22467,23 @@ fn aiur_fn_208(
   })
 }
 
-const INPUT_SIZE_209: usize = 3;
-const IN_209: usize = 3;
-const OUT_209: usize = 1;
-fn aiur_fn_209(
-  inp: [G; IN_209],
+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_209], ExecError> {
+) -> Result<[G; OUT_212], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_209] = [__v_0];
-        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_212] = [__v_0];
+        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -23050,15 +22493,15 @@ fn aiur_fn_209(
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_1, __v_2]; 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_209] = [__v_6];
-            record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_212] = [__v_6];
+            record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __ret: [G; OUT_209] = [__v_0];
-            record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_212] = [__v_0];
+            record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -23067,25 +22510,25 @@ fn aiur_fn_209(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0];
-        let __ret: [G; OUT_209] = [__v_3];
-        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_212] = [__v_3];
+        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_210: usize = 3;
-const IN_210: usize = 3;
-const OUT_210: usize = 1;
-fn aiur_fn_210(
-  inp: [G; IN_210],
+const INPUT_SIZE_213: usize = 3;
+const IN_213: usize = 3;
+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_210], ExecError> {
+) -> Result<[G; OUT_213], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23105,8 +22548,8 @@ fn aiur_fn_210(
         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_210] = [__v_14];
-        record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_213] = [__v_14];
+        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23116,7 +22559,7 @@ fn aiur_fn_210(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
@@ -23126,13 +22569,13 @@ fn aiur_fn_210(
                     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_210] = [__v_13];
-                    record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_213] = [__v_13];
+                    record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __ret: [G; OUT_210] = [__v_0];
-                    record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_213] = [__v_0];
+                    record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -23147,17 +22590,17 @@ fn aiur_fn_210(
                 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_210] = [__v_15];
-                record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_213] = [__v_15];
+                record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_5, __v_1, __v_2]; 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];
                 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_210] = [__v_12];
-                record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_213] = [__v_12];
+                record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -23171,15 +22614,15 @@ fn aiur_fn_210(
   })
 }
 
-const INPUT_SIZE_211: usize = 4;
-const IN_211: usize = 4;
-const OUT_211: usize = 1;
-fn aiur_fn_211(
-  inp: [G; IN_211],
+const INPUT_SIZE_214: usize = 4;
+const IN_214: usize = 4;
+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_211], ExecError> {
+) -> Result<[G; OUT_214], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23204,8 +22647,8 @@ fn aiur_fn_211(
         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_211] = [__v_19];
-        record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_214] = [__v_19];
+        record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23215,17 +22658,17 @@ fn aiur_fn_211(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __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];
             match __v_10.as_canonical_u64() {
               0u64 => {
                 let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
                 let __v_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_211] = [__v_14];
-                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_214] = [__v_14];
+                record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
@@ -23239,17 +22682,17 @@ fn aiur_fn_211(
                 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_211] = [__v_20];
-                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_214] = [__v_20];
+                record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                 let __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_211] = [__v_13];
-                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_214] = [__v_13];
+                record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -23263,15 +22706,15 @@ fn aiur_fn_211(
   })
 }
 
-const INPUT_SIZE_212: usize = 4;
-const IN_212: usize = 4;
-const OUT_212: usize = 1;
-fn aiur_fn_212(
-  inp: [G; IN_212],
+const INPUT_SIZE_215: usize = 4;
+const IN_215: usize = 4;
+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_212], ExecError> {
+) -> Result<[G; OUT_215], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23283,63 +22726,63 @@ fn aiur_fn_212(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_3, __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_7: G = __r_arr[0];
-        let __ret: [G; OUT_212] = [__v_7];
-        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_215] = [__v_7];
+        record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_2 + __v_7);
-        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_212] = [__v_9];
-        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_215] = [__v_9];
+        record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_6, __v_1, __v_2, __v_7]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_212] = [__v_8];
-        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_215] = [__v_8];
+        record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_5, __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 __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_212] = [__v_7];
-        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_215] = [__v_7];
+        record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __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 __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_3, __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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_8, __v_5, __v_2]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_212] = [__v_10];
-            record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_215] = [__v_10];
+            record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_212] = [__v_3];
-                record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_215] = [__v_3];
+                record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_212] = [__v_9];
-                record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_215] = [__v_9];
+                record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -23356,15 +22799,15 @@ fn aiur_fn_212(
   })
 }
 
-const INPUT_SIZE_213: usize = 5;
-const IN_213: usize = 5;
-const OUT_213: usize = 1;
-fn aiur_fn_213(
-  inp: [G; IN_213],
+const INPUT_SIZE_216: usize = 5;
+const IN_216: usize = 5;
+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_213], ExecError> {
+) -> Result<[G; OUT_216], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23377,55 +22820,55 @@ fn aiur_fn_213(
     let __v_7: G = __loaded[2];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_4, __v_2, __v_3]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_213] = [__v_8];
-        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_216] = [__v_8];
+        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_3 + __v_8);
-        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_2, __v_3, __v_4]; 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_6, __v_2, __v_9, __v_10]; 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_213] = [__v_11];
-        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_216] = [__v_11];
+        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_6, __v_2, __v_3, __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 __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_6, __v_2, __v_3, __v_4]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_7, __v_2, __v_3, __v_8]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_213] = [__v_9];
-        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_216] = [__v_9];
+        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_7, __v_2, __v_3, __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 __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_7, __v_2, __v_3, __v_4]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_6, __v_7, __v_2, __v_3, __v_8]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_213] = [__v_9];
-        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_216] = [__v_9];
+        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_6, __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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_4, __v_2, __v_3]; 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_9, __v_3, __v_11]; 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_213] = [__v_12];
-            record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_216] = [__v_12];
+            record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -23434,17 +22877,17 @@ fn aiur_fn_213(
     break '__mc_0 [__v_4];
   },
   _ => {
-    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     break '__mc_0 [__v_10];
   },
 }
  };
             let __v_10: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_2, __v_3, __v_10]; 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_11: G = __r_arr[0];
-            let __ret: [G; OUT_213] = [__v_11];
-            record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_216] = [__v_11];
+            record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -23459,15 +22902,15 @@ fn aiur_fn_213(
   })
 }
 
-const INPUT_SIZE_214: usize = 2;
-const IN_214: usize = 2;
-const OUT_214: usize = 1;
-fn aiur_fn_214(
-  inp: [G; IN_214],
+const INPUT_SIZE_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_214], ExecError> {
+) -> Result<[G; OUT_217], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23477,19 +22920,19 @@ fn aiur_fn_214(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_214] = [__v_0];
-        record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_217] = [__v_0];
+        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_4, __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_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_214] = [__v_8];
-        record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_217] = [__v_8];
+        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -23499,15 +22942,15 @@ fn aiur_fn_214(
   })
 }
 
-const INPUT_SIZE_215: usize = 2;
-const IN_215: usize = 2;
-const OUT_215: usize = 1;
-fn aiur_fn_215(
-  inp: [G; IN_215],
+const INPUT_SIZE_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_215], ExecError> {
+) -> Result<[G; OUT_218], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23517,8 +22960,8 @@ fn aiur_fn_215(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_215] = [__v_0];
-        record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_218] = [__v_0];
+        record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23534,18 +22977,18 @@ fn aiur_fn_215(
             let __v_10: G = __loaded[2];
             match __v_8.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_8, __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 __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0, __v_4]; 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_12: G = __r_arr[0];
-                    let __ret: [G; OUT_215] = [__v_12];
-                    record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_218] = [__v_12];
+                    record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
                     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
   0u64 => {
@@ -23578,7 +23021,7 @@ fn aiur_fn_215(
     break '__mc_2 [__v_17];
   },
   0u64 => {
-    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__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_17: G = __r_arr[0];
     let __v_18: G = G::from_u64(1);
     let __v_19: G = (__v_17 + __v_18);
@@ -23619,7 +23062,7 @@ fn aiur_fn_215(
         break '__mc_3 [__v_7];
       },
       0u64 => {
-        let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
         break '__mc_3 [__v_17];
       },
@@ -23635,10 +23078,10 @@ fn aiur_fn_215(
  };
                     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_215] = { let __args: [G; IN_215] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_15, __v_4]; 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_16: G = __r_arr[0];
-                    let __ret: [G; OUT_215] = [__v_16];
-                    record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_218] = [__v_16];
+                    record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -23654,15 +23097,15 @@ fn aiur_fn_215(
   })
 }
 
-const INPUT_SIZE_216: usize = 2;
-const IN_216: usize = 2;
-const OUT_216: usize = 1;
-fn aiur_fn_216(
-  inp: [G; IN_216],
+const INPUT_SIZE_219: usize = 2;
+const IN_219: usize = 2;
+const OUT_219: usize = 1;
+fn aiur_fn_219(
+  inp: [G; IN_219],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_216], ExecError> {
+) -> Result<[G; OUT_219], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23679,14 +23122,14 @@ fn aiur_fn_216(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_216] = [__v_8];
-            record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_219] = [__v_8];
+            record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_216] = [__v_8];
-            record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_219] = [__v_8];
+            record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -23702,8 +23145,8 @@ fn aiur_fn_216(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_216] = [__v_8];
-            record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_219] = [__v_8];
+            record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -23719,27 +23162,27 @@ fn aiur_fn_216(
                 let __v_13: G = __loaded[2];
                 match __v_11.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
                     let __v_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_206] = { let __args: [G; IN_206] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_10, __v_13]; 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_16: G = __r_arr[0];
                             match __v_16.as_canonical_u64() {
                               1u64 => {
-                                let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_4, __v_7]; 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_17: G = __r_arr[0];
-                                let __ret: [G; OUT_216] = [__v_17];
-                                record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_219] = [__v_17];
+                                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
                                 let __v_17: G = G::from_u64(0);
-                                let __ret: [G; OUT_216] = [__v_17];
-                                record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_219] = [__v_17];
+                                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -23749,16 +23192,16 @@ fn aiur_fn_216(
                           },
                           _ => {
                             let __v_16: G = G::from_u64(0);
-                            let __ret: [G; OUT_216] = [__v_16];
-                            record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_219] = [__v_16];
+                            record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_15: G = G::from_u64(0);
-                        let __ret: [G; OUT_216] = [__v_15];
-                        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_219] = [__v_15];
+                        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -23779,15 +23222,15 @@ fn aiur_fn_216(
   })
 }
 
-const INPUT_SIZE_217: usize = 3;
-const IN_217: usize = 3;
-const OUT_217: usize = 1;
-fn aiur_fn_217(
-  inp: [G; IN_217],
+const INPUT_SIZE_220: usize = 3;
+const IN_220: usize = 3;
+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_217], ExecError> {
+) -> Result<[G; OUT_220], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23799,8 +23242,8 @@ fn aiur_fn_217(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_217] = [__v_6];
-        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_220] = [__v_6];
+        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23810,14 +23253,14 @@ fn aiur_fn_217(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_5, __v_1, __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_10: G = __r_arr[0];
-                let __ret: [G; OUT_217] = [__v_10];
-                record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_220] = [__v_10];
+                record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -23828,7 +23271,7 @@ fn aiur_fn_217(
     break '__mc_0 [__v_11];
   },
   1u64 => {
-    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_8, __v_2]; 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 __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_8, __v_2]; 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];
     break '__mc_0 [__v_11];
   },
@@ -23841,15 +23284,15 @@ fn aiur_fn_217(
                 match __v_11.as_canonical_u64() {
                   1u64 => {
                     let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_217] = [__v_12];
-                    record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_220] = [__v_12];
+                    record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_5, __v_1, __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_12: G = __r_arr[0];
-                    let __ret: [G; OUT_217] = [__v_12];
-                    record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_220] = [__v_12];
+                    record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -23868,15 +23311,15 @@ fn aiur_fn_217(
   })
 }
 
-const INPUT_SIZE_218: usize = 2;
-const IN_218: usize = 2;
-const OUT_218: usize = 1;
-fn aiur_fn_218(
-  inp: [G; IN_218],
+const INPUT_SIZE_221: usize = 2;
+const IN_221: usize = 2;
+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_218], ExecError> {
+) -> 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];
@@ -23887,8 +23330,8 @@ fn aiur_fn_218(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_218] = [__v_5];
-        record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_221] = [__v_5];
+        record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23903,15 +23346,15 @@ fn aiur_fn_218(
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_218] = [__v_10];
-                record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_221] = [__v_10];
+                record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_4, __v_1]; 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_10: G = __r_arr[0];
-                let __ret: [G; OUT_218] = [__v_10];
-                record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_221] = [__v_10];
+                record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -23928,15 +23371,15 @@ fn aiur_fn_218(
   })
 }
 
-const INPUT_SIZE_219: usize = 4;
-const IN_219: usize = 4;
-const OUT_219: usize = 1;
-fn aiur_fn_219(
-  inp: [G; IN_219],
+const INPUT_SIZE_222: usize = 4;
+const IN_222: usize = 4;
+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_219], ExecError> {
+) -> Result<[G; OUT_222], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23949,8 +23392,8 @@ fn aiur_fn_219(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_219] = [__v_7];
-        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_222] = [__v_7];
+        record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23960,31 +23403,31 @@ fn aiur_fn_219(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !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_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_6, __v_1, __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];
-                let __ret: [G; OUT_219] = [__v_11];
-                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_222] = [__v_11];
+                record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_9, __v_2, __v_3]; 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 __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_9, __v_2, __v_3]; 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_11: G = __r_arr[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));
+                    let __ret: [G; OUT_222] = [__v_12];
+                    record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_6, __v_1, __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_12: G = __r_arr[0];
-                    let __ret: [G; OUT_219] = [__v_12];
-                    record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_222] = [__v_12];
+                    record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -24003,15 +23446,15 @@ fn aiur_fn_219(
   })
 }
 
-const INPUT_SIZE_220: usize = 3;
-const IN_220: usize = 3;
-const OUT_220: usize = 1;
-fn aiur_fn_220(
-  inp: [G; IN_220],
+const INPUT_SIZE_223: usize = 3;
+const IN_223: usize = 3;
+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_220], ExecError> {
+) -> 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];
@@ -24023,8 +23466,8 @@ fn aiur_fn_220(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_220] = [__v_6];
-        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_223] = [__v_6];
+        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -24040,15 +23483,15 @@ fn aiur_fn_220(
                 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));
+                    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_220] = { let __args: [G; IN_220] = [__v_5, __v_1, __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 __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_1, __v_2]; 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_220] = [__v_10];
-                    record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_223] = [__v_10];
+                    record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -24057,10 +23500,10 @@ fn aiur_fn_220(
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_5, __v_1, __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 __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_1, __v_2]; 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_220] = [__v_9];
-                record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_223] = [__v_9];
+                record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -24074,15 +23517,15 @@ fn aiur_fn_220(
   })
 }
 
-const INPUT_SIZE_221: usize = 2;
-const IN_221: usize = 2;
-const OUT_221: usize = 1;
-fn aiur_fn_221(
-  inp: [G; IN_221],
+const INPUT_SIZE_224: usize = 2;
+const IN_224: usize = 2;
+const OUT_224: usize = 1;
+fn aiur_fn_224(
+  inp: [G; IN_224],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_221], ExecError> {
+) -> Result<[G; OUT_224], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24093,8 +23536,8 @@ fn aiur_fn_221(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_221] = [__v_5];
-        record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_224] = [__v_5];
+        record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -24110,7 +23553,7 @@ fn aiur_fn_221(
     break '__mc_0 [__v_8];
   },
   _ => {
-    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_1, __v_5, __v_6]; 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 __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_1, __v_5, __v_6]; 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_8: G = __r_arr[0];
     break '__mc_0 [__v_8];
   },
@@ -24120,25 +23563,25 @@ fn aiur_fn_221(
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_221] = [__v_9];
-                record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_222] = { let __args: [G; IN_222] = [__v_7, __v_1, __v_5]; 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 __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_7, __v_1, __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_9: G = __r_arr[0];
                 match __v_9.as_canonical_u64() {
                   0u64 => {
                     let __v_10: G = G::from_u64(0);
-                    let __ret: [G; OUT_221] = [__v_10];
-                    record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_224] = [__v_10];
+                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_4, __v_1]; 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_221] = [__v_10];
-                    record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_224] = [__v_10];
+                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -24160,15 +23603,15 @@ fn aiur_fn_221(
   })
 }
 
-const INPUT_SIZE_222: usize = 3;
-const IN_222: usize = 3;
-const OUT_222: usize = 1;
-fn aiur_fn_222(
-  inp: [G; IN_222],
+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_222], ExecError> {
+) -> Result<[G; OUT_225], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24180,8 +23623,8 @@ fn aiur_fn_222(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_222] = [__v_6];
-        record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_225] = [__v_6];
+        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -24190,20 +23633,20 @@ fn aiur_fn_222(
         let __v_7: G = __loaded[1];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_1, __v_2, __v_6, __v_7]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_1, __v_2, __v_6, __v_7]; 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_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_222] = [__v_9];
-                record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_225] = [__v_9];
+                record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_5, __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_9: G = __r_arr[0];
-                let __ret: [G; OUT_222] = [__v_9];
-                record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_225] = [__v_9];
+                record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -24220,15 +23663,15 @@ fn aiur_fn_222(
   })
 }
 
-const INPUT_SIZE_223: usize = 1;
-const IN_223: usize = 1;
-const OUT_223: usize = 1;
-fn aiur_fn_223(
-  inp: [G; IN_223],
+const INPUT_SIZE_226: usize = 1;
+const IN_226: usize = 1;
+const OUT_226: usize = 1;
+fn aiur_fn_226(
+  inp: [G; IN_226],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_223], ExecError> {
+) -> Result<[G; OUT_226], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -24248,35 +23691,35 @@ fn aiur_fn_223(
     let __v_15: G = G::from_u64(1);
     let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_17: G = G::from_u64(0);
-    let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_16, __v_17, __v_13]; 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_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_18, __v_18]; 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_19: G = __r_arr[0];
-    let __ret: [G; OUT_223] = [__v_19];
-    record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_226] = [__v_19];
+    record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_224: usize = 2;
-const IN_224: usize = 2;
-const OUT_224: usize = 1;
-fn aiur_fn_224(
-  inp: [G; IN_224],
+const INPUT_SIZE_227: usize = 2;
+const IN_227: usize = 2;
+const OUT_227: usize = 1;
+fn aiur_fn_227(
+  inp: [G; IN_227],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_224], ExecError> {
+) -> Result<[G; OUT_227], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_224] = [__v_3];
-        record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_227] = [__v_3];
+        record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -24287,19 +23730,19 @@ fn aiur_fn_224(
         match __v_3.as_canonical_u64() {
           0u64 => {
             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));
+            let __ret: [G; OUT_227] = [__v_6];
+            record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_0]; 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 __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0]; 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_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__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 __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_1]; 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_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_6, __v_7]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_224] = [__v_8];
-            record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_227] = [__v_8];
+            record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -24311,36 +23754,36 @@ fn aiur_fn_224(
   })
 }
 
-const INPUT_SIZE_225: usize = 2;
-const IN_225: usize = 2;
-const OUT_225: usize = 1;
-fn aiur_fn_225(
-  inp: [G; IN_225],
+const INPUT_SIZE_228: usize = 2;
+const IN_228: usize = 2;
+const OUT_228: usize = 1;
+fn aiur_fn_228(
+  inp: [G; IN_228],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_225], ExecError> {
+) -> Result<[G; OUT_228], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_225] = [__v_3];
-        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_228] = [__v_3];
+        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_0]; 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 __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0]; 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__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 __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_1]; 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_3, __v_4]; 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_225] = [__v_5];
-        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_228] = [__v_5];
+        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24350,15 +23793,15 @@ fn aiur_fn_225(
   })
 }
 
-const INPUT_SIZE_226: usize = 2;
-const IN_226: usize = 2;
-const OUT_226: usize = 1;
-fn aiur_fn_226(
-  inp: [G; IN_226],
+const INPUT_SIZE_229: usize = 2;
+const IN_229: usize = 2;
+const OUT_229: usize = 1;
+fn aiur_fn_229(
+  inp: [G; IN_229],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_226], ExecError> {
+) -> Result<[G; OUT_229], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24368,8 +23811,8 @@ fn aiur_fn_226(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_226] = [__v_1];
-        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_229] = [__v_1];
+        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24379,17 +23822,17 @@ fn aiur_fn_226(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_226] = [__v_0];
-            record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_229] = [__v_0];
+            record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_1]; 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_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_226] = [__v_0];
-                record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_229] = [__v_0];
+                record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -24406,19 +23849,19 @@ fn aiur_fn_226(
                     match __v_12.as_canonical_u64() {
                       1u64 => {
                         let __v_15: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_10, __v_13]; 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 __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10, __v_13]; 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 = G::from_u64(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_226] = [__v_18];
-                        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_229] = [__v_18];
+                        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_15: G = G::from_u64(2);
                         let __v_16: G = { let __values: [G; 3] = [__v_15, __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_226] = [__v_16];
-                        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_229] = [__v_16];
+                        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -24426,8 +23869,8 @@ fn aiur_fn_226(
                   _ => {
                     let __v_12: G = G::from_u64(2);
                     let __v_13: G = { let __values: [G; 3] = [__v_12, __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_226] = [__v_13];
-                    record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_229] = [__v_13];
+                    record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -24443,15 +23886,15 @@ fn aiur_fn_226(
   })
 }
 
-const INPUT_SIZE_227: usize = 2;
-const IN_227: usize = 2;
-const OUT_227: usize = 1;
-fn aiur_fn_227(
-  inp: [G; IN_227],
+const INPUT_SIZE_230: usize = 2;
+const IN_230: usize = 2;
+const OUT_230: usize = 1;
+fn aiur_fn_230(
+  inp: [G; IN_230],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_227], ExecError> {
+) -> Result<[G; OUT_230], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24464,26 +23907,26 @@ fn aiur_fn_227(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_227] = [__v_7];
-        record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_230] = [__v_7];
+        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_1]; 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_227] = [__v_5];
-        record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_230] = [__v_5];
+        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_1]; 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_227] = [__v_6];
-            record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_230] = [__v_6];
+            record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -24493,24 +23936,24 @@ fn aiur_fn_227(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_227] = [__v_1];
-                record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_230] = [__v_1];
+                record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_1]; 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() {
                   1u64 => {
-                    let __ret: [G; OUT_227] = [__v_0];
-                    record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_230] = [__v_0];
+                    record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_10: G = G::from_u64(3);
                     let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_227] = [__v_11];
-                    record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_230] = [__v_11];
+                    record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -24529,15 +23972,15 @@ fn aiur_fn_227(
   })
 }
 
-const INPUT_SIZE_228: usize = 1;
-const IN_228: usize = 1;
-const OUT_228: usize = 1;
-fn aiur_fn_228(
-  inp: [G; IN_228],
+const INPUT_SIZE_231: usize = 1;
+const IN_231: usize = 1;
+const OUT_231: usize = 1;
+fn aiur_fn_231(
+  inp: [G; IN_231],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_228], ExecError> {
+) -> Result<[G; OUT_231], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -24549,48 +23992,48 @@ fn aiur_fn_228(
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
         let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_228] = [__v_6];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_231] = [__v_6];
+        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_4: G = G::from_u64(4);
         let __v_5: G = G::from_u64(0);
         let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_228] = [__v_6];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_231] = [__v_6];
+        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2]; 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_2]; 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_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(0);
         let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_228] = [__v_7];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_231] = [__v_7];
+        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2]; 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_2]; 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_3]; 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_4, __v_5]; 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 __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_4, __v_5]; 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_228] = [__v_6];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_231] = [__v_6];
+        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2]; 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_2]; 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_3]; 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_4, __v_5]; 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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__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_6: G = __r_arr[0];
-        let __ret: [G; OUT_228] = [__v_6];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_231] = [__v_6];
+        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24600,15 +24043,15 @@ fn aiur_fn_228(
   })
 }
 
-const INPUT_SIZE_229: usize = 2;
-const IN_229: usize = 2;
-const OUT_229: usize = 1;
-fn aiur_fn_229(
-  inp: [G; IN_229],
+const INPUT_SIZE_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_229], ExecError> {
+) -> Result<[G; OUT_232], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24621,47 +24064,47 @@ fn aiur_fn_229(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_229] = [__v_7];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_232] = [__v_7];
+        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3, __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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
         let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_229] = [__v_8];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_232] = [__v_8];
+        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3, __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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_4, __v_1]; 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 __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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_5, __v_6]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_229] = [__v_7];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_232] = [__v_7];
+        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3, __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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_4, __v_1]; 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 __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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_5, __v_6]; 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 __ret: [G; OUT_229] = [__v_7];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_232] = [__v_7];
+        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_229] = [__v_5];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_232] = [__v_5];
+        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24671,15 +24114,15 @@ fn aiur_fn_229(
   })
 }
 
-const INPUT_SIZE_230: usize = 2;
-const IN_230: usize = 2;
-const OUT_230: usize = 1;
-fn aiur_fn_230(
-  inp: [G; IN_230],
+const INPUT_SIZE_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_230], ExecError> {
+) -> 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];
@@ -24692,19 +24135,19 @@ fn aiur_fn_230(
         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_230] = [__v_7];
-        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_233] = [__v_7];
+        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3, __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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4, __v_1]; 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 __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_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_230] = [__v_8];
-        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_233] = [__v_8];
+        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24714,15 +24157,15 @@ fn aiur_fn_230(
   })
 }
 
-const INPUT_SIZE_231: usize = 2;
-const IN_231: usize = 2;
-const OUT_231: usize = 1;
-fn aiur_fn_231(
-  inp: [G; IN_231],
+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_231], ExecError> {
+) -> Result<[G; OUT_234], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24732,30 +24175,30 @@ fn aiur_fn_231(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_231] = [__v_0];
-        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_234] = [__v_0];
+        record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __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 __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_231] = [__v_5];
-        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_234] = [__v_5];
+        record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_232: usize = 2;
-const IN_232: usize = 2;
-const OUT_232: usize = 1;
-fn aiur_fn_232(
-  inp: [G; IN_232],
+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_232], ExecError> {
+) -> Result<[G; OUT_235], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24769,94 +24212,94 @@ fn aiur_fn_232(
         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_232] = [__v_8];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_235] = [__v_8];
+        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3, __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_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_232] = [__v_9];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_235] = [__v_9];
+        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_6: G = G::from_u64(2);
-        let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4, __v_1]; 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 __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_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_232] = [__v_9];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_235] = [__v_9];
+        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_6: G = G::from_u64(3);
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_3, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_3, __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4, __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_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_232] = [__v_10];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_235] = [__v_10];
+        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_6: G = G::from_u64(4);
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_3, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_3, __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4, __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_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_232] = [__v_10];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_235] = [__v_10];
+        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_6: G = G::from_u64(5);
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_3, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_3, __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4, __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_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_232] = [__v_10];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_235] = [__v_10];
+        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_6: G = G::from_u64(6);
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_3, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_3, __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4, __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_5, __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_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_232] = [__v_10];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_235] = [__v_10];
+        record.function_queries[235].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_232] = [__v_8];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_235] = [__v_8];
+        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_6: G = G::from_u64(8);
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_5, __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_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_232] = [__v_8];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_235] = [__v_8];
+        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24866,15 +24309,15 @@ fn aiur_fn_232(
   })
 }
 
-const INPUT_SIZE_233: usize = 2;
-const IN_233: usize = 2;
-const OUT_233: usize = 1;
-fn aiur_fn_233(
-  inp: [G; IN_233],
+const INPUT_SIZE_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_233], ExecError> {
+) -> 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];
@@ -24905,14 +24348,14 @@ fn aiur_fn_233(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_22: G = G::from_u64(1);
-            let __ret: [G; OUT_233] = [__v_22];
-            record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_236] = [__v_22];
+            record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_233] = [__v_22];
-            record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_236] = [__v_22];
+            record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -24932,25 +24375,25 @@ fn aiur_fn_233(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_233] = [__v_22];
-            record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_236] = [__v_22];
+            record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[6].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_6] = unsafe { *(result.output.as_ptr() as *const [G; OUT_6]) }; __ret } else { aiur_fn_6(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
             match __v_22.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_11, __v_21]; 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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_11, __v_21]; 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_23: G = __r_arr[0];
-                let __ret: [G; OUT_233] = [__v_23];
-                record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_236] = [__v_23];
+                record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_233] = [__v_23];
-                record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_236] = [__v_23];
+                record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -24970,15 +24413,15 @@ fn aiur_fn_233(
   })
 }
 
-const INPUT_SIZE_234: usize = 2;
-const IN_234: usize = 2;
-const OUT_234: usize = 1;
-fn aiur_fn_234(
-  inp: [G; IN_234],
+const INPUT_SIZE_237: usize = 2;
+const IN_237: usize = 2;
+const OUT_237: usize = 1;
+fn aiur_fn_237(
+  inp: [G; IN_237],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_234], ExecError> {
+) -> Result<[G; OUT_237], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24995,14 +24438,14 @@ fn aiur_fn_234(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_234] = [__v_8];
-            record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_237] = [__v_8];
+            record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_234] = [__v_8];
-            record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_237] = [__v_8];
+            record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -25015,24 +24458,24 @@ fn aiur_fn_234(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_234] = [__v_8];
-            record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_237] = [__v_8];
+            record.function_queries[237].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_234] = { let __args: [G; IN_234] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_234] = [__v_9];
-                record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_237] = [__v_9];
+                record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_234] = [__v_9];
-                record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_237] = [__v_9];
+                record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -25049,15 +24492,15 @@ fn aiur_fn_234(
   })
 }
 
-const INPUT_SIZE_235: usize = 4;
-const IN_235: usize = 4;
-const OUT_235: usize = 1;
-fn aiur_fn_235(
-  inp: [G; IN_235],
+const INPUT_SIZE_238: usize = 4;
+const IN_238: usize = 4;
+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_235], ExecError> {
+) -> Result<[G; OUT_238], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -25067,16 +24510,16 @@ fn aiur_fn_235(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_3]; 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 __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_235] = [__v_4];
-            record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_238] = [__v_4];
+            record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_235] = [__v_4];
-            record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_238] = [__v_4];
+            record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -25084,16 +24527,16 @@ fn aiur_fn_235(
       1u64 => {
         match __v_2.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_1, __v_3]; 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_4: G = __r_arr[0];
-            let __ret: [G; OUT_235] = [__v_4];
-            record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_238] = [__v_4];
+            record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_235] = [__v_4];
-            record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_238] = [__v_4];
+            record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -25105,15 +24548,15 @@ fn aiur_fn_235(
   })
 }
 
-const INPUT_SIZE_236: usize = 0;
-const IN_236: usize = 0;
-const OUT_236: usize = 1;
-fn aiur_fn_236(
-  inp: [G; IN_236],
+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_236], ExecError> {
+) -> Result<[G; OUT_239], 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);
@@ -25148,21 +24591,21 @@ fn aiur_fn_236(
     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_236] = [__v_32];
-    record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_239] = [__v_32];
+    record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_237: usize = 0;
-const IN_237: usize = 0;
-const OUT_237: usize = 1;
-fn aiur_fn_237(
-  inp: [G; IN_237],
+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_237], ExecError> {
+) -> Result<[G; OUT_240], 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);
@@ -25197,21 +24640,21 @@ fn aiur_fn_237(
     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_237] = [__v_32];
-    record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_240] = [__v_32];
+    record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_238: usize = 0;
-const IN_238: usize = 0;
-const OUT_238: usize = 1;
-fn aiur_fn_238(
-  inp: [G; IN_238],
+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_238], ExecError> {
+) -> Result<[G; OUT_241], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(141);
     let __v_1: G = G::from_u64(196);
@@ -25246,21 +24689,21 @@ fn aiur_fn_238(
     let __v_30: G = G::from_u64(123);
     let __v_31: G = G::from_u64(208);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_238] = [__v_32];
-    record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_241] = [__v_32];
+    record.function_queries[241].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],
+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_239], ExecError> {
+) -> Result<[G; OUT_242], 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);
@@ -25295,21 +24738,21 @@ fn aiur_fn_239(
     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_239] = [__v_32];
-    record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_242] = [__v_32];
+    record.function_queries[242].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],
+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_240], ExecError> {
+) -> Result<[G; OUT_243], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(105);
     let __v_1: G = G::from_u64(141);
@@ -25344,21 +24787,21 @@ fn aiur_fn_240(
     let __v_30: G = G::from_u64(62);
     let __v_31: G = G::from_u64(174);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_240] = [__v_32];
-    record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_243] = [__v_32];
+    record.function_queries[243].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],
+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_241], ExecError> {
+) -> Result<[G; OUT_244], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(119);
     let __v_1: G = G::from_u64(160);
@@ -25393,21 +24836,21 @@ fn aiur_fn_241(
     let __v_30: G = G::from_u64(228);
     let __v_31: G = G::from_u64(228);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_244] = [__v_32];
+    record.function_queries[244].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],
+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_242], ExecError> {
+) -> Result<[G; OUT_245], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(144);
     let __v_1: G = G::from_u64(202);
@@ -25442,21 +24885,21 @@ fn aiur_fn_242(
     let __v_30: G = G::from_u64(165);
     let __v_31: G = G::from_u64(116);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_242] = [__v_32];
-    record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_245] = [__v_32];
+    record.function_queries[245].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],
+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_243], ExecError> {
+) -> Result<[G; OUT_246], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(159);
     let __v_1: G = G::from_u64(216);
@@ -25491,21 +24934,21 @@ fn aiur_fn_243(
     let __v_30: G = G::from_u64(61);
     let __v_31: G = G::from_u64(116);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_243] = [__v_32];
-    record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_246] = [__v_32];
+    record.function_queries[246].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],
+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_244], ExecError> {
+) -> Result<[G; OUT_247], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(197);
     let __v_1: G = G::from_u64(247);
@@ -25540,21 +24983,21 @@ fn aiur_fn_244(
     let __v_30: G = G::from_u64(55);
     let __v_31: G = G::from_u64(35);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_244] = [__v_32];
-    record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_247] = [__v_32];
+    record.function_queries[247].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],
+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_245], ExecError> {
+) -> Result<[G; OUT_248], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(202);
     let __v_1: G = G::from_u64(202);
@@ -25589,21 +25032,21 @@ fn aiur_fn_245(
     let __v_30: G = G::from_u64(51);
     let __v_31: G = G::from_u64(18);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_245] = [__v_32];
-    record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_248] = [__v_32];
+    record.function_queries[248].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],
+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_246], ExecError> {
+) -> Result<[G; OUT_249], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(230);
     let __v_1: G = G::from_u64(235);
@@ -25638,21 +25081,21 @@ fn aiur_fn_246(
     let __v_30: G = G::from_u64(160);
     let __v_31: G = G::from_u64(164);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_246] = [__v_32];
-    record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_249] = [__v_32];
+    record.function_queries[249].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],
+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_247], ExecError> {
+) -> Result<[G; OUT_250], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(3);
     let __v_1: G = G::from_u64(107);
@@ -25687,21 +25130,21 @@ fn aiur_fn_247(
     let __v_30: G = G::from_u64(224);
     let __v_31: G = G::from_u64(201);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_247] = [__v_32];
-    record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_250] = [__v_32];
+    record.function_queries[250].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],
+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_248], ExecError> {
+) -> Result<[G; OUT_251], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(108);
     let __v_1: G = G::from_u64(155);
@@ -25736,21 +25179,21 @@ fn aiur_fn_248(
     let __v_30: G = G::from_u64(173);
     let __v_31: G = G::from_u64(206);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_248] = [__v_32];
-    record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_251] = [__v_32];
+    record.function_queries[251].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],
+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_249], ExecError> {
+) -> Result<[G; OUT_252], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(236);
     let __v_1: G = G::from_u64(31);
@@ -25785,21 +25228,21 @@ fn aiur_fn_249(
     let __v_30: G = G::from_u64(110);
     let __v_31: G = G::from_u64(190);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_252] = [__v_32];
+    record.function_queries[252].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],
+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_250], ExecError> {
+) -> Result<[G; OUT_253], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(180);
     let __v_1: G = G::from_u64(178);
@@ -25834,21 +25277,21 @@ fn aiur_fn_250(
     let __v_30: G = G::from_u64(137);
     let __v_31: G = G::from_u64(87);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_250] = [__v_32];
-    record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_253] = [__v_32];
+    record.function_queries[253].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],
+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_251], ExecError> {
+) -> Result<[G; OUT_254], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(192);
     let __v_1: G = G::from_u64(19);
@@ -25883,21 +25326,21 @@ fn aiur_fn_251(
     let __v_30: G = G::from_u64(146);
     let __v_31: G = G::from_u64(29);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_254] = [__v_32];
+    record.function_queries[254].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],
+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_252], ExecError> {
+) -> Result<[G; OUT_255], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(131);
     let __v_1: G = G::from_u64(253);
@@ -25932,21 +25375,21 @@ fn aiur_fn_252(
     let __v_30: G = G::from_u64(7);
     let __v_31: G = G::from_u64(93);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_252] = [__v_32];
-    record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_255] = [__v_32];
+    record.function_queries[255].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],
+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_253], ExecError> {
+) -> Result<[G; OUT_256], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(56);
     let __v_1: G = G::from_u64(214);
@@ -25981,21 +25424,21 @@ fn aiur_fn_253(
     let __v_30: G = G::from_u64(116);
     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_253] = [__v_32];
-    record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_256] = [__v_32];
+    record.function_queries[256].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],
+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_254], ExecError> {
+) -> Result<[G; OUT_257], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(85);
     let __v_1: G = G::from_u64(104);
@@ -26030,21 +25473,21 @@ fn aiur_fn_254(
     let __v_30: G = G::from_u64(249);
     let __v_31: G = G::from_u64(86);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_257] = [__v_32];
+    record.function_queries[257].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],
+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_255], ExecError> {
+) -> Result<[G; OUT_258], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(9);
     let __v_1: G = G::from_u64(188);
@@ -26079,21 +25522,21 @@ fn aiur_fn_255(
     let __v_30: G = G::from_u64(211);
     let __v_31: G = G::from_u64(220);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_255] = [__v_32];
-    record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_258] = [__v_32];
+    record.function_queries[258].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],
+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_256], ExecError> {
+) -> Result<[G; OUT_259], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(38);
     let __v_1: G = G::from_u64(124);
@@ -26128,21 +25571,21 @@ fn aiur_fn_256(
     let __v_30: G = G::from_u64(73);
     let __v_31: G = G::from_u64(241);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_256] = [__v_32];
-    record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_259] = [__v_32];
+    record.function_queries[259].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],
+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_257], ExecError> {
+) -> Result<[G; OUT_260], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(116);
     let __v_1: G = G::from_u64(89);
@@ -26177,21 +25620,21 @@ fn aiur_fn_257(
     let __v_30: G = G::from_u64(91);
     let __v_31: G = G::from_u64(151);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_257] = [__v_32];
-    record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_260] = [__v_32];
+    record.function_queries[260].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],
+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_258], ExecError> {
+) -> Result<[G; OUT_261], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(171);
     let __v_1: G = G::from_u64(55);
@@ -26226,21 +25669,21 @@ fn aiur_fn_258(
     let __v_30: G = G::from_u64(87);
     let __v_31: G = G::from_u64(25);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_258] = [__v_32];
-    record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_261] = [__v_32];
+    record.function_queries[261].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],
+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_259], ExecError> {
+) -> Result<[G; OUT_262], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(15);
     let __v_1: G = G::from_u64(158);
@@ -26275,21 +25718,21 @@ fn aiur_fn_259(
     let __v_30: G = G::from_u64(131);
     let __v_31: G = G::from_u64(129);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_259] = [__v_32];
-    record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_262] = [__v_32];
+    record.function_queries[262].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],
+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_260], ExecError> {
+) -> Result<[G; OUT_263], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(4);
     let __v_1: G = G::from_u64(113);
@@ -26324,21 +25767,21 @@ fn aiur_fn_260(
     let __v_30: G = G::from_u64(87);
     let __v_31: G = G::from_u64(149);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_260] = [__v_32];
-    record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_263] = [__v_32];
+    record.function_queries[263].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],
+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_261], ExecError> {
+) -> Result<[G; OUT_264], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(33);
     let __v_1: G = G::from_u64(224);
@@ -26373,21 +25816,21 @@ fn aiur_fn_261(
     let __v_30: G = G::from_u64(240);
     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_261] = [__v_32];
-    record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_264] = [__v_32];
+    record.function_queries[264].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],
+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_262], ExecError> {
+) -> Result<[G; OUT_265], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(1);
     let __v_1: G = G::from_u64(131);
@@ -26422,21 +25865,21 @@ fn aiur_fn_262(
     let __v_30: G = G::from_u64(109);
     let __v_31: G = G::from_u64(72);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_265] = [__v_32];
+    record.function_queries[265].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],
+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_263], ExecError> {
+) -> Result<[G; OUT_266], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(156);
     let __v_1: G = G::from_u64(230);
@@ -26471,21 +25914,21 @@ fn aiur_fn_263(
     let __v_30: G = G::from_u64(96);
     let __v_31: G = G::from_u64(183);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_266] = [__v_32];
+    record.function_queries[266].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],
+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_264], ExecError> {
+) -> Result<[G; OUT_267], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(60);
     let __v_1: G = G::from_u64(245);
@@ -26520,21 +25963,21 @@ fn aiur_fn_264(
     let __v_30: G = G::from_u64(251);
     let __v_31: G = G::from_u64(200);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_267] = [__v_32];
+    record.function_queries[267].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],
+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_265], ExecError> {
+) -> Result<[G; OUT_268], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(28);
     let __v_1: G = G::from_u64(23);
@@ -26569,21 +26012,21 @@ fn aiur_fn_265(
     let __v_30: G = G::from_u64(250);
     let __v_31: G = G::from_u64(120);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_265] = [__v_32];
-    record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_268] = [__v_32];
+    record.function_queries[268].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],
+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_266], ExecError> {
+) -> Result<[G; OUT_269], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(22);
     let __v_1: G = G::from_u64(133);
@@ -26618,21 +26061,21 @@ fn aiur_fn_266(
     let __v_30: G = G::from_u64(229);
     let __v_31: G = G::from_u64(96);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_266] = [__v_32];
-    record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_269] = [__v_32];
+    record.function_queries[269].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],
+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_267], ExecError> {
+) -> Result<[G; OUT_270], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(207);
     let __v_1: G = G::from_u64(134);
@@ -26667,21 +26110,21 @@ fn aiur_fn_267(
     let __v_30: G = G::from_u64(118);
     let __v_31: G = G::from_u64(216);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_270] = [__v_32];
+    record.function_queries[270].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],
+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_268], ExecError> {
+) -> Result<[G; OUT_271], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(245);
     let __v_1: G = G::from_u64(210);
@@ -26716,21 +26159,21 @@ fn aiur_fn_268(
     let __v_30: G = G::from_u64(232);
     let __v_31: G = G::from_u64(95);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_271] = [__v_32];
+    record.function_queries[271].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],
+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_269], ExecError> {
+) -> Result<[G; OUT_272], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(11);
     let __v_1: G = G::from_u64(89);
@@ -26765,21 +26208,21 @@ fn aiur_fn_269(
     let __v_30: G = G::from_u64(96);
     let __v_31: G = G::from_u64(146);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_272] = [__v_32];
+    record.function_queries[272].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],
+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_270], ExecError> {
+) -> Result<[G; OUT_273], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(123);
     let __v_1: G = G::from_u64(216);
@@ -26814,21 +26257,21 @@ fn aiur_fn_270(
     let __v_30: G = G::from_u64(64);
     let __v_31: G = G::from_u64(18);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_270] = [__v_32];
-    record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_273] = [__v_32];
+    record.function_queries[273].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],
+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_271], ExecError> {
+) -> Result<[G; OUT_274], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(56);
     let __v_1: G = G::from_u64(151);
@@ -26863,21 +26306,21 @@ fn aiur_fn_271(
     let __v_30: G = G::from_u64(25);
     let __v_31: G = G::from_u64(205);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_274] = [__v_32];
+    record.function_queries[274].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],
+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_272], ExecError> {
+) -> Result<[G; OUT_275], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(45);
     let __v_1: G = G::from_u64(252);
@@ -26912,21 +26355,21 @@ fn aiur_fn_272(
     let __v_30: G = G::from_u64(105);
     let __v_31: G = G::from_u64(91);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_272] = [__v_32];
-    record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_275] = [__v_32];
+    record.function_queries[275].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],
+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_273], ExecError> {
+) -> Result<[G; OUT_276], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(146);
     let __v_1: G = G::from_u64(50);
@@ -26961,21 +26404,21 @@ fn aiur_fn_273(
     let __v_30: G = G::from_u64(15);
     let __v_31: G = G::from_u64(235);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_273] = [__v_32];
-    record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_276] = [__v_32];
+    record.function_queries[276].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],
+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_274], ExecError> {
+) -> Result<[G; OUT_277], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(57);
     let __v_1: G = G::from_u64(138);
@@ -27010,21 +26453,21 @@ fn aiur_fn_274(
     let __v_30: G = G::from_u64(182);
     let __v_31: G = G::from_u64(49);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_274] = [__v_32];
-    record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_277] = [__v_32];
+    record.function_queries[277].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],
+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_275], ExecError> {
+) -> Result<[G; OUT_278], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(211);
     let __v_1: G = G::from_u64(151);
@@ -27059,21 +26502,21 @@ fn aiur_fn_275(
     let __v_30: G = G::from_u64(125);
     let __v_31: G = G::from_u64(182);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_275] = [__v_32];
-    record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_278] = [__v_32];
+    record.function_queries[278].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],
+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_276], ExecError> {
+) -> Result<[G; OUT_279], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(222);
     let __v_1: G = G::from_u64(245);
@@ -27108,21 +26551,21 @@ fn aiur_fn_276(
     let __v_30: G = G::from_u64(5);
     let __v_31: G = G::from_u64(110);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_276] = [__v_32];
-    record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_279] = [__v_32];
+    record.function_queries[279].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],
+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_277], ExecError> {
+) -> Result<[G; OUT_280], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(145);
     let __v_1: G = G::from_u64(79);
@@ -27157,21 +26600,21 @@ fn aiur_fn_277(
     let __v_30: G = G::from_u64(76);
     let __v_31: G = G::from_u64(136);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_277] = [__v_32];
-    record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_280] = [__v_32];
+    record.function_queries[280].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],
+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_278], ExecError> {
+) -> Result<[G; OUT_281], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(214);
     let __v_1: G = G::from_u64(246);
@@ -27206,21 +26649,21 @@ fn aiur_fn_278(
     let __v_30: G = G::from_u64(201);
     let __v_31: G = G::from_u64(105);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_281] = [__v_32];
+    record.function_queries[281].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],
+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_279], ExecError> {
+) -> Result<[G; OUT_282], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(253);
     let __v_1: G = G::from_u64(189);
@@ -27255,21 +26698,21 @@ fn aiur_fn_279(
     let __v_30: G = G::from_u64(114);
     let __v_31: G = G::from_u64(176);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_282] = [__v_32];
+    record.function_queries[282].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],
+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_280], ExecError> {
+) -> Result<[G; OUT_283], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(102);
     let __v_1: G = G::from_u64(73);
@@ -27304,21 +26747,21 @@ fn aiur_fn_280(
     let __v_30: G = G::from_u64(150);
     let __v_31: G = G::from_u64(217);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_280] = [__v_32];
-    record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_283] = [__v_32];
+    record.function_queries[283].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],
+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_281], ExecError> {
+) -> Result<[G; OUT_284], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(51);
     let __v_1: G = G::from_u64(198);
@@ -27353,21 +26796,21 @@ fn aiur_fn_281(
     let __v_30: G = G::from_u64(161);
     let __v_31: G = G::from_u64(207);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_281] = [__v_32];
-    record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_284] = [__v_32];
+    record.function_queries[284].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],
+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_282], ExecError> {
+) -> Result<[G; OUT_285], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(59);
     let __v_1: G = G::from_u64(228);
@@ -27402,21 +26845,21 @@ fn aiur_fn_282(
     let __v_30: G = G::from_u64(167);
     let __v_31: G = G::from_u64(151);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_282] = [__v_32];
-    record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_285] = [__v_32];
+    record.function_queries[285].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],
+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_283], ExecError> {
+) -> Result<[G; OUT_286], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(81);
     let __v_1: G = G::from_u64(121);
@@ -27451,21 +26894,21 @@ fn aiur_fn_283(
     let __v_30: G = G::from_u64(161);
     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_283] = [__v_32];
-    record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_286] = [__v_32];
+    record.function_queries[286].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],
+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_284], ExecError> {
+) -> Result<[G; OUT_287], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(137);
     let __v_1: G = G::from_u64(222);
@@ -27500,21 +26943,21 @@ fn aiur_fn_284(
     let __v_30: G = G::from_u64(83);
     let __v_31: G = G::from_u64(98);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_284] = [__v_32];
-    record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_287] = [__v_32];
+    record.function_queries[287].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],
+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_285], ExecError> {
+) -> Result<[G; OUT_288], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(129);
     let __v_1: G = G::from_u64(138);
@@ -27549,21 +26992,21 @@ fn aiur_fn_285(
     let __v_30: G = G::from_u64(142);
     let __v_31: G = G::from_u64(248);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_285] = [__v_32];
-    record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_288] = [__v_32];
+    record.function_queries[288].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],
+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_286], ExecError> {
+) -> Result<[G; OUT_289], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(155);
     let __v_1: G = G::from_u64(118);
@@ -27598,21 +27041,21 @@ fn aiur_fn_286(
     let __v_30: G = G::from_u64(243);
     let __v_31: G = G::from_u64(151);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_286] = [__v_32];
-    record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_289] = [__v_32];
+    record.function_queries[289].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],
+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_287], ExecError> {
+) -> Result<[G; OUT_290], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(151);
     let __v_1: G = G::from_u64(227);
@@ -27647,21 +27090,21 @@ fn aiur_fn_287(
     let __v_30: G = G::from_u64(237);
     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_287] = [__v_32];
-    record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_290] = [__v_32];
+    record.function_queries[290].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],
+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_288], ExecError> {
+) -> Result<[G; OUT_291], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(220);
     let __v_1: G = G::from_u64(129);
@@ -27696,21 +27139,21 @@ fn aiur_fn_288(
     let __v_30: G = G::from_u64(217);
     let __v_31: G = G::from_u64(84);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_291] = [__v_32];
+    record.function_queries[291].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],
+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_289], ExecError> {
+) -> Result<[G; OUT_292], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(109);
     let __v_1: G = G::from_u64(180);
@@ -27745,21 +27188,21 @@ fn aiur_fn_289(
     let __v_30: G = G::from_u64(186);
     let __v_31: G = G::from_u64(138);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_289] = [__v_32];
-    record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_292] = [__v_32];
+    record.function_queries[292].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],
+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_290], ExecError> {
+) -> Result<[G; OUT_293], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(163);
     let __v_1: G = G::from_u64(74);
@@ -27794,21 +27237,21 @@ fn aiur_fn_290(
     let __v_30: G = G::from_u64(68);
     let __v_31: G = G::from_u64(184);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_290] = [__v_32];
-    record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_293] = [__v_32];
+    record.function_queries[293].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],
+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_291], ExecError> {
+) -> Result<[G; OUT_294], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(222);
     let __v_1: G = G::from_u64(11);
@@ -27843,21 +27286,21 @@ fn aiur_fn_291(
     let __v_30: G = G::from_u64(43);
     let __v_31: G = G::from_u64(248);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_291] = [__v_32];
-    record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_294] = [__v_32];
+    record.function_queries[294].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],
+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_292], ExecError> {
+) -> Result<[G; OUT_295], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(122);
     let __v_1: G = G::from_u64(178);
@@ -27892,21 +27335,21 @@ fn aiur_fn_292(
     let __v_30: G = G::from_u64(200);
     let __v_31: G = G::from_u64(253);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_292] = [__v_32];
-    record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_295] = [__v_32];
+    record.function_queries[295].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],
+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_293], ExecError> {
+) -> Result<[G; OUT_296], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(222);
     let __v_1: G = G::from_u64(244);
@@ -27941,21 +27384,21 @@ fn aiur_fn_293(
     let __v_30: G = G::from_u64(234);
     let __v_31: G = G::from_u64(147);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_296] = [__v_32];
+    record.function_queries[296].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],
+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_294], ExecError> {
+) -> Result<[G; OUT_297], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(233);
     let __v_1: G = G::from_u64(92);
@@ -27990,21 +27433,21 @@ fn aiur_fn_294(
     let __v_30: G = G::from_u64(146);
     let __v_31: G = G::from_u64(6);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_297] = [__v_32];
+    record.function_queries[297].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],
+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_295], ExecError> {
+) -> Result<[G; OUT_298], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(107);
     let __v_1: G = G::from_u64(182);
@@ -28039,21 +27482,21 @@ fn aiur_fn_295(
     let __v_30: G = G::from_u64(109);
     let __v_31: G = G::from_u64(172);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_298] = [__v_32];
+    record.function_queries[298].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],
+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_296], ExecError> {
+) -> Result<[G; OUT_299], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(237);
     let __v_1: G = G::from_u64(67);
@@ -28088,21 +27531,21 @@ fn aiur_fn_296(
     let __v_30: G = G::from_u64(173);
     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_296] = [__v_32];
-    record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_299] = [__v_32];
+    record.function_queries[299].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],
+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_297], ExecError> {
+) -> Result<[G; OUT_300], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(124);
     let __v_1: G = G::from_u64(251);
@@ -28137,21 +27580,21 @@ fn aiur_fn_297(
     let __v_30: G = G::from_u64(7);
     let __v_31: G = G::from_u64(68);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_297] = [__v_32];
-    record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_300] = [__v_32];
+    record.function_queries[300].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],
+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_298], ExecError> {
+) -> Result<[G; OUT_301], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(26);
     let __v_1: G = G::from_u64(76);
@@ -28186,21 +27629,21 @@ fn aiur_fn_298(
     let __v_30: G = G::from_u64(220);
     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_298] = [__v_32];
-    record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_301] = [__v_32];
+    record.function_queries[301].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],
+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_299], ExecError> {
+) -> Result<[G; OUT_302], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(41);
     let __v_1: G = G::from_u64(221);
@@ -28235,21 +27678,21 @@ fn aiur_fn_299(
     let __v_30: G = G::from_u64(76);
     let __v_31: G = G::from_u64(121);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_302] = [__v_32];
+    record.function_queries[302].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],
+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_300], ExecError> {
+) -> Result<[G; OUT_303], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(150);
     let __v_1: G = G::from_u64(113);
@@ -28284,21 +27727,21 @@ fn aiur_fn_300(
     let __v_30: G = G::from_u64(153);
     let __v_31: G = G::from_u64(6);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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));
+    let __ret: [G; OUT_303] = [__v_32];
+    record.function_queries[303].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],
+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_301], ExecError> {
+) -> Result<[G; OUT_304], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(37);
     let __v_1: G = G::from_u64(138);
@@ -28333,21 +27776,21 @@ fn aiur_fn_301(
     let __v_30: G = G::from_u64(202);
     let __v_31: G = G::from_u64(62);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_301] = [__v_32];
-    record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_304] = [__v_32];
+    record.function_queries[304].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],
+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_302], ExecError> {
+) -> Result<[G; OUT_305], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(119);
     let __v_1: G = G::from_u64(213);
@@ -28382,21 +27825,21 @@ fn aiur_fn_302(
     let __v_30: G = G::from_u64(2);
     let __v_31: G = G::from_u64(160);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_302] = [__v_32];
-    record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_305] = [__v_32];
+    record.function_queries[305].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],
+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_303], ExecError> {
+) -> Result<[G; OUT_306], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(162);
     let __v_1: G = G::from_u64(154);
@@ -28431,21 +27874,21 @@ fn aiur_fn_303(
     let __v_30: G = G::from_u64(87);
     let __v_31: G = G::from_u64(98);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_303] = [__v_32];
-    record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_306] = [__v_32];
+    record.function_queries[306].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],
+const INPUT_SIZE_307: usize = 0;
+const IN_307: usize = 0;
+const OUT_307: usize = 1;
+fn aiur_fn_307(
+  inp: [G; IN_307],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_304], ExecError> {
+) -> Result<[G; OUT_307], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(221);
     let __v_1: G = G::from_u64(161);
@@ -28480,21 +27923,21 @@ fn aiur_fn_304(
     let __v_30: G = G::from_u64(198);
     let __v_31: G = G::from_u64(62);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_304] = [__v_32];
-    record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_307] = [__v_32];
+    record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_305: usize = 1;
-const IN_305: usize = 1;
-const OUT_305: usize = 1;
-fn aiur_fn_305(
-  inp: [G; IN_305],
+const INPUT_SIZE_308: usize = 1;
+const IN_308: usize = 1;
+const OUT_308: usize = 1;
+fn aiur_fn_308(
+  inp: [G; IN_308],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_305], ExecError> {
+) -> Result<[G; OUT_308], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -28523,8 +27966,8 @@ fn aiur_fn_305(
         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_305] = [__v_23];
-        record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_308] = [__v_23];
+        record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -28536,7 +27979,7 @@ fn aiur_fn_305(
         let __v_16: G = G::from_u64(0);
         let __v_17: G = G::from_u64(0);
         let __v_18: G = G::from_u64(0);
-        let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __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[5].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } else { aiur_fn_5(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -28550,17 +27993,17 @@ fn aiur_fn_305(
           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_305] = [__v_29];
-            record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_308] = [__v_29];
+            record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_28: G = G::from_u64(0);
-            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_10]; 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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_10]; 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_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_305] = [__v_30];
-            record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_308] = [__v_30];
+            record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -28572,15 +28015,15 @@ fn aiur_fn_305(
   })
 }
 
-const INPUT_SIZE_306: usize = 3;
-const IN_306: usize = 3;
-const OUT_306: usize = 1;
-fn aiur_fn_306(
-  inp: [G; IN_306],
+const INPUT_SIZE_309: usize = 3;
+const IN_309: usize = 3;
+const OUT_309: usize = 1;
+fn aiur_fn_309(
+  inp: [G; IN_309],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_306], ExecError> {
+) -> Result<[G; OUT_309], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28600,15 +28043,15 @@ fn aiur_fn_306(
       1u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_306] = [__v_1];
-            record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_309] = [__v_1];
+            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_1]; 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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !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_13: G = __r_arr[0];
-            let __ret: [G; OUT_306] = [__v_13];
-            record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_309] = [__v_13];
+            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -28629,21 +28072,21 @@ fn aiur_fn_306(
           1u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_306] = [__v_0];
-                record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_309] = [__v_0];
+                record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0]; 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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !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_23: G = __r_arr[0];
-                let __ret: [G; OUT_306] = [__v_23];
-                record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_309] = [__v_23];
+                record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           0u64 => {
-            let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } else { aiur_fn_5(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -28660,7 +28103,7 @@ fn aiur_fn_306(
             let __v_36: G = G::from_u64(0);
             let __v_37: G = G::from_u64(0);
             let __v_38: G = G::from_u64(0);
-            let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } else { aiur_fn_5(__args, record, io_buffer, __cu)? } };
             let __v_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
             let __v_41: G = __r_arr[2];
@@ -28672,11 +28115,11 @@ fn aiur_fn_306(
             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_306] = { let __args: [G; IN_306] = [__v_12, __v_22, __v_48]; 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 __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_12, __v_22, __v_48]; 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_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_306] = [__v_51];
-            record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_309] = [__v_51];
+            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -28691,36 +28134,36 @@ fn aiur_fn_306(
   })
 }
 
-const INPUT_SIZE_307: usize = 2;
-const IN_307: usize = 2;
-const OUT_307: usize = 1;
-fn aiur_fn_307(
-  inp: [G; IN_307],
+const INPUT_SIZE_310: usize = 2;
+const IN_310: usize = 2;
+const OUT_310: usize = 1;
+fn aiur_fn_310(
+  inp: [G; IN_310],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_307], ExecError> {
+) -> Result<[G; OUT_310], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_1, __v_2]; 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 __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __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_3: G = __r_arr[0];
-    let __ret: [G; OUT_307] = [__v_3];
-    record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_310] = [__v_3];
+    record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_308: usize = 16;
-const IN_308: usize = 16;
-const OUT_308: usize = 9;
-fn aiur_fn_308(
-  inp: [G; IN_308],
+const INPUT_SIZE_311: usize = 16;
+const IN_311: usize = 16;
+const OUT_311: usize = 9;
+fn aiur_fn_311(
+  inp: [G; IN_311],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_308], ExecError> {
+) -> Result<[G; OUT_311], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28790,21 +28233,21 @@ fn aiur_fn_308(
     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_308] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
-    record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_311] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
+    record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_309: usize = 3;
-const IN_309: usize = 3;
-const OUT_309: usize = 2;
-fn aiur_fn_309(
-  inp: [G; IN_309],
+const INPUT_SIZE_312: usize = 3;
+const IN_312: usize = 3;
+const OUT_312: usize = 2;
+fn aiur_fn_312(
+  inp: [G; IN_312],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_309], ExecError> {
+) -> Result<[G; OUT_312], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28838,8 +28281,8 @@ fn aiur_fn_309(
             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_309] = [__v_25, __v_2];
-            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_312] = [__v_25, __v_2];
+            record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -28847,8 +28290,8 @@ fn aiur_fn_309(
             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_309] = [__v_25, __v_26];
-            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_312] = [__v_25, __v_26];
+            record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -28873,8 +28316,8 @@ fn aiur_fn_309(
             match __v_2.as_canonical_u64() {
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_309] = [__v_0, __v_23];
-                record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_312] = [__v_0, __v_23];
+                record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -28886,7 +28329,7 @@ fn aiur_fn_309(
                 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_308] = { let __args: [G; IN_308] = [__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[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 __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__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[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_31: G = __r_arr[0];
                 let __v_32: G = __r_arr[1];
                 let __v_33: G = __r_arr[2];
@@ -28899,19 +28342,19 @@ fn aiur_fn_309(
                 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_309] = { let __args: [G; IN_309] = [__v_12, __v_42, __v_39]; 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 __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_12, __v_42, __v_39]; 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_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_309] = [__v_46, __v_44];
-                record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_312] = [__v_46, __v_44];
+                record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           0u64 => {
-            let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__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[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 __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__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[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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -28928,7 +28371,7 @@ fn aiur_fn_309(
             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_308] = { let __args: [G; IN_308] = [__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[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 __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__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[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_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
             let __v_41: G = __r_arr[2];
@@ -28939,13 +28382,13 @@ fn aiur_fn_309(
             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_309] = { let __args: [G; IN_309] = [__v_12, __v_22, __v_48]; 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 __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_12, __v_22, __v_48]; 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_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_309] = [__v_52, __v_50];
-            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_312] = [__v_52, __v_50];
+            record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -28960,15 +28403,15 @@ fn aiur_fn_309(
   })
 }
 
-const INPUT_SIZE_310: usize = 1;
-const IN_310: usize = 1;
-const OUT_310: usize = 1;
-fn aiur_fn_310(
-  inp: [G; IN_310],
+const INPUT_SIZE_313: usize = 1;
+const IN_313: usize = 1;
+const OUT_313: usize = 1;
+fn aiur_fn_313(
+  inp: [G; IN_313],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_310], ExecError> {
+) -> Result<[G; OUT_313], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -28987,12 +28430,12 @@ fn aiur_fn_310(
         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_310] = [__v_13];
-        record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_313] = [__v_13];
+        record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_10]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_10]; 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_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];
@@ -29014,8 +28457,8 @@ fn aiur_fn_310(
                 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_310] = [__v_25];
-                record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_313] = [__v_25];
+                record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -29024,8 +28467,8 @@ fn aiur_fn_310(
                 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_310] = [__v_27];
-                record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_313] = [__v_27];
+                record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -29036,8 +28479,8 @@ fn aiur_fn_310(
           _ => {
             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_310] = [__v_23];
-            record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_313] = [__v_23];
+            record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -29049,20 +28492,20 @@ fn aiur_fn_310(
   })
 }
 
-const INPUT_SIZE_311: usize = 2;
-const IN_311: usize = 2;
-const OUT_311: usize = 1;
-fn aiur_fn_311(
-  inp: [G; IN_311],
+const INPUT_SIZE_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_311], ExecError> {
+) -> Result<[G; OUT_314], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __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 __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0, __v_1, __v_2]; 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 __v_4: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -29070,15 +28513,15 @@ fn aiur_fn_311(
         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_311] = [__v_7];
-        record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_314] = [__v_7];
+        record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !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_5: G = __r_arr[0];
-        let __ret: [G; OUT_311] = [__v_5];
-        record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_314] = [__v_5];
+        record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29088,19 +28531,19 @@ fn aiur_fn_311(
   })
 }
 
-const INPUT_SIZE_312: usize = 2;
-const IN_312: usize = 2;
-const OUT_312: usize = 1;
-fn aiur_fn_312(
-  inp: [G; IN_312],
+const INPUT_SIZE_315: usize = 2;
+const IN_315: usize = 2;
+const OUT_315: usize = 1;
+fn aiur_fn_315(
+  inp: [G; IN_315],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_312], ExecError> {
+) -> Result<[G; OUT_315], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __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];
@@ -29116,29 +28559,29 @@ fn aiur_fn_312(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_13: G = G::from_u64(1);
-        let __ret: [G; OUT_312] = [__v_13];
-        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_315] = [__v_13];
+        record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_312] = [__v_13];
-        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_315] = [__v_13];
+        record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_313: usize = 1;
-const IN_313: usize = 1;
-const OUT_313: usize = 1;
-fn aiur_fn_313(
-  inp: [G; IN_313],
+const INPUT_SIZE_316: usize = 1;
+const IN_316: usize = 1;
+const OUT_316: usize = 1;
+fn aiur_fn_316(
+  inp: [G; IN_316],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_313], ExecError> {
+) -> Result<[G; OUT_316], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -29154,23 +28597,23 @@ fn aiur_fn_313(
     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_311] = { let __args: [G; IN_311] = [__v_0, __v_13]; 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 __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !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_14: G = __r_arr[0];
-    let __ret: [G; OUT_313] = [__v_14];
-    record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_316] = [__v_14];
+    record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_314: usize = 2;
-const IN_314: usize = 2;
-const OUT_314: usize = 2;
-fn aiur_fn_314(
-  inp: [G; IN_314],
+const INPUT_SIZE_317: usize = 2;
+const IN_317: usize = 2;
+const OUT_317: usize = 2;
+fn aiur_fn_317(
+  inp: [G; IN_317],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_314], ExecError> {
+) -> Result<[G; OUT_317], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29178,8 +28621,8 @@ fn aiur_fn_314(
     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_314] = [__v_0, __v_1];
-        record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_317] = [__v_0, __v_1];
+        record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -29187,11 +28630,11 @@ fn aiur_fn_314(
         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_314] = { let __args: [G; IN_314] = [__v_5, __v_7]; 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 __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_314] = [__v_8, __v_9];
-        record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_317] = [__v_8, __v_9];
+        record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29201,40 +28644,40 @@ fn aiur_fn_314(
   })
 }
 
-const INPUT_SIZE_315: usize = 1;
-const IN_315: usize = 1;
-const OUT_315: usize = 3;
-fn aiur_fn_315(
-  inp: [G; IN_315],
+const INPUT_SIZE_318: usize = 1;
+const IN_318: usize = 1;
+const OUT_318: usize = 3;
+fn aiur_fn_318(
+  inp: [G; IN_318],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_315], ExecError> {
+) -> Result<[G; OUT_318], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
     let __v_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_314] = { let __args: [G; IN_314] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_315] = [__v_2, __v_5, __v_6];
-    record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_318] = [__v_2, __v_5, __v_6];
+    record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_316: usize = 16;
-const IN_316: usize = 16;
-const OUT_316: usize = 16;
-fn aiur_fn_316(
-  inp: [G; IN_316],
+const INPUT_SIZE_319: usize = 16;
+const IN_319: usize = 16;
+const OUT_319: usize = 16;
+fn aiur_fn_319(
+  inp: [G; IN_319],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_316], ExecError> {
+) -> Result<[G; OUT_319], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29365,7 +28808,7 @@ fn aiur_fn_316(
     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_315] = { let __args: [G; IN_315] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_129: G = __r_arr[0];
     let __v_130: G = __r_arr[1];
     let __v_131: G = __r_arr[2];
@@ -29376,19 +28819,19 @@ fn aiur_fn_316(
     let __v_136: G = G::from_u64(0);
     let __v_137: G = if unconstrained { Bytes2::xor(&__v_131, &__v_136) } else { bytes2_xor_value(__v_131, __v_136, record) };
     let __v_138: G = G::from_u64(256);
-    let __v_139: G = (__v_138 * __v_135);
-    let __v_140: G = G::from_u64(65536);
-    let __v_141: G = (__v_140 * __v_137);
-    let __v_142: G = (__v_139 + __v_141);
-    let __v_143: G = (__v_133 + __v_142);
-    if (__v_16 != __v_143) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_143.as_canonical_u64() });
-    }
-    let __v_144: G = G::from_u64(256);
+    let __v_139: G = (__v_138 * __v_137);
+    let __v_140: G = (__v_135 + __v_139);
+    let __v_141: G = (__v_19 + __v_140);
+    let __v_142: G = G::from_u64(256);
+    let __v_143: G = (__v_142 * __v_135);
+    let __v_144: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_147]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_146: G = (__v_143 + __v_145);
+    let __v_147: G = (__v_133 + __v_146);
+    if (__v_16 != __v_147) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_147.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_148: G = __r_arr[0];
     let __v_149: G = __r_arr[1];
     let __v_150: G = __r_arr[2];
@@ -29399,19 +28842,19 @@ fn aiur_fn_316(
     let __v_155: G = G::from_u64(0);
     let __v_156: G = if unconstrained { Bytes2::xor(&__v_150, &__v_155) } else { bytes2_xor_value(__v_150, __v_155, record) };
     let __v_157: G = G::from_u64(256);
-    let __v_158: G = (__v_157 * __v_154);
-    let __v_159: G = G::from_u64(65536);
-    let __v_160: G = (__v_159 * __v_156);
-    let __v_161: G = (__v_158 + __v_160);
-    let __v_162: G = (__v_152 + __v_161);
-    if (__v_147 != __v_162) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_147.as_canonical_u64(), rhs: __v_162.as_canonical_u64() });
-    }
-    let __v_163: G = G::from_u64(256);
+    let __v_158: G = (__v_157 * __v_156);
+    let __v_159: G = (__v_154 + __v_158);
+    let __v_160: G = (__v_24 + __v_159);
+    let __v_161: G = G::from_u64(256);
+    let __v_162: G = (__v_161 * __v_154);
+    let __v_163: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_166]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_165: G = (__v_162 + __v_164);
+    let __v_166: G = (__v_152 + __v_165);
+    if (__v_141 != __v_166) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_166.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_167: G = __r_arr[0];
     let __v_168: G = __r_arr[1];
     let __v_169: G = __r_arr[2];
@@ -29422,19 +28865,19 @@ fn aiur_fn_316(
     let __v_174: G = G::from_u64(0);
     let __v_175: G = if unconstrained { Bytes2::xor(&__v_169, &__v_174) } else { bytes2_xor_value(__v_169, __v_174, record) };
     let __v_176: G = G::from_u64(256);
-    let __v_177: G = (__v_176 * __v_173);
-    let __v_178: G = G::from_u64(65536);
-    let __v_179: G = (__v_178 * __v_175);
-    let __v_180: G = (__v_177 + __v_179);
-    let __v_181: G = (__v_171 + __v_180);
-    if (__v_166 != __v_181) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_181.as_canonical_u64() });
-    }
-    let __v_182: G = G::from_u64(256);
+    let __v_177: G = (__v_176 * __v_175);
+    let __v_178: G = (__v_173 + __v_177);
+    let __v_179: G = (__v_31 + __v_178);
+    let __v_180: G = G::from_u64(256);
+    let __v_181: G = (__v_180 * __v_173);
+    let __v_182: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_185]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_184: G = (__v_181 + __v_183);
+    let __v_185: G = (__v_171 + __v_184);
+    if (__v_160 != __v_185) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_185.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_186: G = __r_arr[0];
     let __v_187: G = __r_arr[1];
     let __v_188: G = __r_arr[2];
@@ -29445,19 +28888,19 @@ fn aiur_fn_316(
     let __v_193: G = G::from_u64(0);
     let __v_194: G = if unconstrained { Bytes2::xor(&__v_188, &__v_193) } else { bytes2_xor_value(__v_188, __v_193, record) };
     let __v_195: G = G::from_u64(256);
-    let __v_196: G = (__v_195 * __v_192);
-    let __v_197: G = G::from_u64(65536);
-    let __v_198: G = (__v_197 * __v_194);
-    let __v_199: G = (__v_196 + __v_198);
-    let __v_200: G = (__v_190 + __v_199);
-    if (__v_185 != __v_200) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_185.as_canonical_u64(), rhs: __v_200.as_canonical_u64() });
-    }
-    let __v_201: G = G::from_u64(256);
+    let __v_196: G = (__v_195 * __v_194);
+    let __v_197: G = (__v_192 + __v_196);
+    let __v_198: G = (__v_40 + __v_197);
+    let __v_199: G = G::from_u64(256);
+    let __v_200: G = (__v_199 * __v_192);
+    let __v_201: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_204]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_203: G = (__v_200 + __v_202);
+    let __v_204: G = (__v_190 + __v_203);
+    if (__v_179 != __v_204) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_204.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_205: G = __r_arr[0];
     let __v_206: G = __r_arr[1];
     let __v_207: G = __r_arr[2];
@@ -29468,19 +28911,19 @@ fn aiur_fn_316(
     let __v_212: G = G::from_u64(0);
     let __v_213: G = if unconstrained { Bytes2::xor(&__v_207, &__v_212) } else { bytes2_xor_value(__v_207, __v_212, record) };
     let __v_214: G = G::from_u64(256);
-    let __v_215: G = (__v_214 * __v_211);
-    let __v_216: G = G::from_u64(65536);
-    let __v_217: G = (__v_216 * __v_213);
-    let __v_218: G = (__v_215 + __v_217);
-    let __v_219: G = (__v_209 + __v_218);
-    if (__v_204 != __v_219) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_204.as_canonical_u64(), rhs: __v_219.as_canonical_u64() });
-    }
-    let __v_220: G = G::from_u64(256);
+    let __v_215: G = (__v_214 * __v_213);
+    let __v_216: G = (__v_211 + __v_215);
+    let __v_217: G = (__v_51 + __v_216);
+    let __v_218: G = G::from_u64(256);
+    let __v_219: G = (__v_218 * __v_211);
+    let __v_220: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_223]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_222: G = (__v_219 + __v_221);
+    let __v_223: G = (__v_209 + __v_222);
+    if (__v_198 != __v_223) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_223.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_224: G = __r_arr[0];
     let __v_225: G = __r_arr[1];
     let __v_226: G = __r_arr[2];
@@ -29491,19 +28934,19 @@ fn aiur_fn_316(
     let __v_231: G = G::from_u64(0);
     let __v_232: G = if unconstrained { Bytes2::xor(&__v_226, &__v_231) } else { bytes2_xor_value(__v_226, __v_231, record) };
     let __v_233: G = G::from_u64(256);
-    let __v_234: G = (__v_233 * __v_230);
-    let __v_235: G = G::from_u64(65536);
-    let __v_236: G = (__v_235 * __v_232);
-    let __v_237: G = (__v_234 + __v_236);
-    let __v_238: G = (__v_228 + __v_237);
-    if (__v_223 != __v_238) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_238.as_canonical_u64() });
-    }
-    let __v_239: G = G::from_u64(256);
+    let __v_234: G = (__v_233 * __v_232);
+    let __v_235: G = (__v_230 + __v_234);
+    let __v_236: G = (__v_64 + __v_235);
+    let __v_237: G = G::from_u64(256);
+    let __v_238: G = (__v_237 * __v_230);
+    let __v_239: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_242]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_241: G = (__v_238 + __v_240);
+    let __v_242: G = (__v_228 + __v_241);
+    if (__v_217 != __v_242) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_242.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_243: G = __r_arr[0];
     let __v_244: G = __r_arr[1];
     let __v_245: G = __r_arr[2];
@@ -29514,19 +28957,19 @@ fn aiur_fn_316(
     let __v_250: G = G::from_u64(0);
     let __v_251: G = if unconstrained { Bytes2::xor(&__v_245, &__v_250) } else { bytes2_xor_value(__v_245, __v_250, record) };
     let __v_252: G = G::from_u64(256);
-    let __v_253: G = (__v_252 * __v_249);
-    let __v_254: G = G::from_u64(65536);
-    let __v_255: G = (__v_254 * __v_251);
-    let __v_256: G = (__v_253 + __v_255);
-    let __v_257: G = (__v_247 + __v_256);
-    if (__v_242 != __v_257) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_257.as_canonical_u64() });
-    }
-    let __v_258: G = G::from_u64(256);
+    let __v_253: G = (__v_252 * __v_251);
+    let __v_254: G = (__v_249 + __v_253);
+    let __v_255: G = (__v_79 + __v_254);
+    let __v_256: G = G::from_u64(256);
+    let __v_257: G = (__v_256 * __v_249);
+    let __v_258: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_261]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_260: G = (__v_257 + __v_259);
+    let __v_261: G = (__v_247 + __v_260);
+    if (__v_236 != __v_261) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_261.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_262: G = __r_arr[0];
     let __v_263: G = __r_arr[1];
     let __v_264: G = __r_arr[2];
@@ -29537,19 +28980,19 @@ fn aiur_fn_316(
     let __v_269: G = G::from_u64(0);
     let __v_270: G = if unconstrained { Bytes2::xor(&__v_264, &__v_269) } else { bytes2_xor_value(__v_264, __v_269, record) };
     let __v_271: G = G::from_u64(256);
-    let __v_272: G = (__v_271 * __v_268);
-    let __v_273: G = G::from_u64(65536);
-    let __v_274: G = (__v_273 * __v_270);
-    let __v_275: G = (__v_272 + __v_274);
-    let __v_276: G = (__v_266 + __v_275);
-    if (__v_261 != __v_276) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_261.as_canonical_u64(), rhs: __v_276.as_canonical_u64() });
-    }
-    let __v_277: G = G::from_u64(256);
+    let __v_272: G = (__v_271 * __v_270);
+    let __v_273: G = (__v_268 + __v_272);
+    let __v_274: G = (__v_92 + __v_273);
+    let __v_275: G = G::from_u64(256);
+    let __v_276: G = (__v_275 * __v_268);
+    let __v_277: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_280]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_279: G = (__v_276 + __v_278);
+    let __v_280: G = (__v_266 + __v_279);
+    if (__v_255 != __v_280) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_280.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_281: G = __r_arr[0];
     let __v_282: G = __r_arr[1];
     let __v_283: G = __r_arr[2];
@@ -29560,19 +29003,19 @@ fn aiur_fn_316(
     let __v_288: G = G::from_u64(0);
     let __v_289: G = if unconstrained { Bytes2::xor(&__v_283, &__v_288) } else { bytes2_xor_value(__v_283, __v_288, record) };
     let __v_290: G = G::from_u64(256);
-    let __v_291: G = (__v_290 * __v_287);
-    let __v_292: G = G::from_u64(65536);
-    let __v_293: G = (__v_292 * __v_289);
-    let __v_294: G = (__v_291 + __v_293);
-    let __v_295: G = (__v_285 + __v_294);
-    if (__v_280 != __v_295) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_280.as_canonical_u64(), rhs: __v_295.as_canonical_u64() });
-    }
-    let __v_296: G = G::from_u64(256);
+    let __v_291: G = (__v_290 * __v_289);
+    let __v_292: G = (__v_287 + __v_291);
+    let __v_293: G = (__v_103 + __v_292);
+    let __v_294: G = G::from_u64(256);
+    let __v_295: G = (__v_294 * __v_287);
+    let __v_296: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_299]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_298: G = (__v_295 + __v_297);
+    let __v_299: G = (__v_285 + __v_298);
+    if (__v_274 != __v_299) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_299.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_300: G = __r_arr[0];
     let __v_301: G = __r_arr[1];
     let __v_302: G = __r_arr[2];
@@ -29583,19 +29026,19 @@ fn aiur_fn_316(
     let __v_307: G = G::from_u64(0);
     let __v_308: G = if unconstrained { Bytes2::xor(&__v_302, &__v_307) } else { bytes2_xor_value(__v_302, __v_307, record) };
     let __v_309: G = G::from_u64(256);
-    let __v_310: G = (__v_309 * __v_306);
-    let __v_311: G = G::from_u64(65536);
-    let __v_312: G = (__v_311 * __v_308);
-    let __v_313: G = (__v_310 + __v_312);
-    let __v_314: G = (__v_304 + __v_313);
-    if (__v_299 != __v_314) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_299.as_canonical_u64(), rhs: __v_314.as_canonical_u64() });
-    }
-    let __v_315: G = G::from_u64(256);
+    let __v_310: G = (__v_309 * __v_308);
+    let __v_311: G = (__v_306 + __v_310);
+    let __v_312: G = (__v_112 + __v_311);
+    let __v_313: G = G::from_u64(256);
+    let __v_314: G = (__v_313 * __v_306);
+    let __v_315: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_318]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_317: G = (__v_314 + __v_316);
+    let __v_318: G = (__v_304 + __v_317);
+    if (__v_293 != __v_318) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_293.as_canonical_u64(), rhs: __v_318.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_319: G = __r_arr[0];
     let __v_320: G = __r_arr[1];
     let __v_321: G = __r_arr[2];
@@ -29606,19 +29049,19 @@ fn aiur_fn_316(
     let __v_326: G = G::from_u64(0);
     let __v_327: G = if unconstrained { Bytes2::xor(&__v_321, &__v_326) } else { bytes2_xor_value(__v_321, __v_326, record) };
     let __v_328: G = G::from_u64(256);
-    let __v_329: G = (__v_328 * __v_325);
-    let __v_330: G = G::from_u64(65536);
-    let __v_331: G = (__v_330 * __v_327);
-    let __v_332: G = (__v_329 + __v_331);
-    let __v_333: G = (__v_323 + __v_332);
-    if (__v_318 != __v_333) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_318.as_canonical_u64(), rhs: __v_333.as_canonical_u64() });
-    }
-    let __v_334: G = G::from_u64(256);
+    let __v_329: G = (__v_328 * __v_327);
+    let __v_330: G = (__v_325 + __v_329);
+    let __v_331: G = (__v_119 + __v_330);
+    let __v_332: G = G::from_u64(256);
+    let __v_333: G = (__v_332 * __v_325);
+    let __v_334: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_337]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_336: G = (__v_333 + __v_335);
+    let __v_337: G = (__v_323 + __v_336);
+    if (__v_312 != __v_337) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_312.as_canonical_u64(), rhs: __v_337.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_338: G = __r_arr[0];
     let __v_339: G = __r_arr[1];
     let __v_340: G = __r_arr[2];
@@ -29629,19 +29072,19 @@ fn aiur_fn_316(
     let __v_345: G = G::from_u64(0);
     let __v_346: G = if unconstrained { Bytes2::xor(&__v_340, &__v_345) } else { bytes2_xor_value(__v_340, __v_345, record) };
     let __v_347: G = G::from_u64(256);
-    let __v_348: G = (__v_347 * __v_344);
-    let __v_349: G = G::from_u64(65536);
-    let __v_350: G = (__v_349 * __v_346);
-    let __v_351: G = (__v_348 + __v_350);
-    let __v_352: G = (__v_342 + __v_351);
-    if (__v_337 != __v_352) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_337.as_canonical_u64(), rhs: __v_352.as_canonical_u64() });
-    }
-    let __v_353: G = G::from_u64(256);
+    let __v_348: G = (__v_347 * __v_346);
+    let __v_349: G = (__v_344 + __v_348);
+    let __v_350: G = (__v_124 + __v_349);
+    let __v_351: G = G::from_u64(256);
+    let __v_352: G = (__v_351 * __v_344);
+    let __v_353: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_356]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_355: G = (__v_352 + __v_354);
+    let __v_356: G = (__v_342 + __v_355);
+    if (__v_331 != __v_356) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_331.as_canonical_u64(), rhs: __v_356.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_357: G = __r_arr[0];
     let __v_358: G = __r_arr[1];
     let __v_359: G = __r_arr[2];
@@ -29652,19 +29095,19 @@ fn aiur_fn_316(
     let __v_364: G = G::from_u64(0);
     let __v_365: G = if unconstrained { Bytes2::xor(&__v_359, &__v_364) } else { bytes2_xor_value(__v_359, __v_364, record) };
     let __v_366: G = G::from_u64(256);
-    let __v_367: G = (__v_366 * __v_363);
-    let __v_368: G = G::from_u64(65536);
-    let __v_369: G = (__v_368 * __v_365);
-    let __v_370: G = (__v_367 + __v_369);
-    let __v_371: G = (__v_361 + __v_370);
-    if (__v_356 != __v_371) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_371.as_canonical_u64() });
-    }
-    let __v_372: G = G::from_u64(256);
+    let __v_367: G = (__v_366 * __v_365);
+    let __v_368: G = (__v_363 + __v_367);
+    let __v_369: G = (__v_127 + __v_368);
+    let __v_370: G = G::from_u64(256);
+    let __v_371: G = (__v_370 * __v_363);
+    let __v_372: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_375]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_374: G = (__v_371 + __v_373);
+    let __v_375: G = (__v_361 + __v_374);
+    if (__v_350 != __v_375) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_350.as_canonical_u64(), rhs: __v_375.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_376: G = __r_arr[0];
     let __v_377: G = __r_arr[1];
     let __v_378: G = __r_arr[2];
@@ -29675,19 +29118,19 @@ fn aiur_fn_316(
     let __v_383: G = G::from_u64(0);
     let __v_384: G = if unconstrained { Bytes2::xor(&__v_378, &__v_383) } else { bytes2_xor_value(__v_378, __v_383, record) };
     let __v_385: G = G::from_u64(256);
-    let __v_386: G = (__v_385 * __v_382);
-    let __v_387: G = G::from_u64(65536);
-    let __v_388: G = (__v_387 * __v_384);
-    let __v_389: G = (__v_386 + __v_388);
-    let __v_390: G = (__v_380 + __v_389);
-    if (__v_375 != __v_390) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_375.as_canonical_u64(), rhs: __v_390.as_canonical_u64() });
-    }
-    let __v_391: G = G::from_u64(256);
+    let __v_386: G = (__v_385 * __v_384);
+    let __v_387: G = (__v_382 + __v_386);
+    let __v_388: G = (__v_128 + __v_387);
+    let __v_389: G = G::from_u64(256);
+    let __v_390: G = (__v_389 * __v_382);
+    let __v_391: G = G::from_u64(65536);
     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_315] = { let __args: [G; IN_315] = [__v_394]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_393: G = (__v_390 + __v_392);
+    let __v_394: G = (__v_380 + __v_393);
+    if (__v_369 != __v_394) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_369.as_canonical_u64(), rhs: __v_394.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { 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_395: G = __r_arr[0];
     let __v_396: G = __r_arr[1];
     let __v_397: G = __r_arr[2];
@@ -29698,32 +29141,32 @@ fn aiur_fn_316(
     let __v_402: G = G::from_u64(0);
     let __v_403: G = if unconstrained { Bytes2::xor(&__v_397, &__v_402) } else { bytes2_xor_value(__v_397, __v_402, record) };
     let __v_404: G = G::from_u64(256);
-    let __v_405: G = (__v_404 * __v_401);
-    let __v_406: G = G::from_u64(65536);
-    let __v_407: G = (__v_406 * __v_403);
-    let __v_408: G = (__v_405 + __v_407);
-    let __v_409: G = (__v_399 + __v_408);
-    if (__v_394 != __v_409) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_394.as_canonical_u64(), rhs: __v_409.as_canonical_u64() });
-    }
-    let __v_410: G = G::from_u64(256);
-    let __v_411: G = (__v_410 * __v_403);
-    let __v_412: G = (__v_401 + __v_411);
-    let __ret: [G; OUT_316] = [__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[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_405: G = (__v_404 * __v_403);
+    let __v_406: G = (__v_401 + __v_405);
+    let __v_407: G = G::from_u64(256);
+    let __v_408: G = (__v_407 * __v_401);
+    let __v_409: G = G::from_u64(65536);
+    let __v_410: G = (__v_409 * __v_403);
+    let __v_411: G = (__v_408 + __v_410);
+    let __v_412: G = (__v_399 + __v_411);
+    if (__v_388 != __v_412) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_412.as_canonical_u64() });
+    }
+    let __ret: [G; OUT_319] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406];
+    record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_317: usize = 2;
-const IN_317: usize = 2;
-const OUT_317: usize = 1;
-fn aiur_fn_317(
-  inp: [G; IN_317],
+const INPUT_SIZE_320: usize = 2;
+const IN_320: usize = 2;
+const OUT_320: usize = 1;
+fn aiur_fn_320(
+  inp: [G; IN_320],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_317], ExecError> {
+) -> Result<[G; OUT_320], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29731,23 +29174,23 @@ fn aiur_fn_317(
     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_318] = { let __args: [G; IN_318] = [__v_0, __v_1, __v_4, __v_5]; 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 __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1, __v_4, __v_5]; 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_6: G = __r_arr[0];
-    let __ret: [G; OUT_317] = [__v_6];
-    record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_320] = [__v_6];
+    record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_318: usize = 4;
-const IN_318: usize = 4;
-const OUT_318: usize = 1;
-fn aiur_fn_318(
-  inp: [G; IN_318],
+const INPUT_SIZE_321: usize = 4;
+const IN_321: usize = 4;
+const OUT_321: usize = 1;
+fn aiur_fn_321(
+  inp: [G; IN_321],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_318], ExecError> {
+) -> Result<[G; OUT_321], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29766,8 +29209,8 @@ fn aiur_fn_318(
     let __v_13: G = __loaded[9];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_318] = [__v_2];
-        record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_321] = [__v_2];
+        record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -29782,18 +29225,18 @@ fn aiur_fn_318(
         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_319] = { let __args: [G; IN_319] = [__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[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 __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__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[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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_25, __v_3]; 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 __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_25, __v_3]; 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_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_2, __v_26]; 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 __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_2, __v_26]; 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_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_318] = { let __args: [G; IN_318] = [__v_13, __v_1, __v_27, __v_29]; 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 __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_13, __v_1, __v_27, __v_29]; 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_30: G = __r_arr[0];
-        let __ret: [G; OUT_318] = [__v_30];
-        record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_321] = [__v_30];
+        record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29803,15 +29246,15 @@ fn aiur_fn_318(
   })
 }
 
-const INPUT_SIZE_319: usize = 18;
-const IN_319: usize = 18;
-const OUT_319: usize = 1;
-fn aiur_fn_319(
-  inp: [G; IN_319],
+const INPUT_SIZE_322: usize = 18;
+const IN_322: usize = 18;
+const OUT_322: usize = 1;
+fn aiur_fn_322(
+  inp: [G; IN_322],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_319], ExecError> {
+) -> Result<[G; OUT_322], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29848,15 +29291,15 @@ fn aiur_fn_319(
         let __v_28: G = __r_arr[0];
         match __v_28.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_319] = [__v_17];
-            record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_322] = [__v_17];
+            record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__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[787].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_787] = unsafe { *(result.output.as_ptr() as *const [G; OUT_787]) }; __ret } else { aiur_fn_787(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__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[790].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_790] = unsafe { *(result.output.as_ptr() as *const [G; OUT_790]) }; __ret } else { aiur_fn_790(__args, record, io_buffer, __cu)? } };
             let __v_29: G = __r_arr[0];
-            let __ret: [G; OUT_319] = [__v_29];
-            record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_322] = [__v_29];
+            record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -29865,7 +29308,7 @@ fn aiur_fn_319(
         }
       },
       0u64 => {
-        let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__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[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 __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__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[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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -29882,7 +29325,7 @@ fn aiur_fn_319(
         let __v_41: G = __r_arr[13];
         let __v_42: G = __r_arr[14];
         let __v_43: G = __r_arr[15];
-        let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } else { aiur_fn_5(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -29899,7 +29342,7 @@ fn aiur_fn_319(
         let __v_57: G = G::from_u64(0);
         let __v_58: G = G::from_u64(0);
         let __v_59: G = G::from_u64(0);
-        let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } else { aiur_fn_5(__args, record, io_buffer, __cu)? } };
         let __v_60: G = __r_arr[0];
         let __v_61: G = __r_arr[1];
         let __v_62: G = __r_arr[2];
@@ -29909,12 +29352,12 @@ fn aiur_fn_319(
         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_787] = { let __args: [G; IN_787] = [__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[787].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_787] = unsafe { *(result.output.as_ptr() as *const [G; OUT_787]) }; __ret } else { aiur_fn_787(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__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[790].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_790] = unsafe { *(result.output.as_ptr() as *const [G; OUT_790]) }; __ret } else { aiur_fn_790(__args, record, io_buffer, __cu)? } };
         let __v_69: G = __r_arr[0];
-        let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__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[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 __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__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[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_70: G = __r_arr[0];
-        let __ret: [G; OUT_319] = [__v_70];
-        record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_322] = [__v_70];
+        record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29924,22 +29367,22 @@ fn aiur_fn_319(
   })
 }
 
-const INPUT_SIZE_320: usize = 2;
-const IN_320: usize = 2;
-const OUT_320: usize = 1;
-fn aiur_fn_320(
-  inp: [G; IN_320],
+const INPUT_SIZE_323: usize = 2;
+const IN_323: usize = 2;
+const OUT_323: usize = 1;
+fn aiur_fn_323(
+  inp: [G; IN_323],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_320], ExecError> {
+) -> Result<[G; OUT_323], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_320] = [__v_0];
-        record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_323] = [__v_0];
+        record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29955,28 +29398,28 @@ fn aiur_fn_320(
         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_320] = { let __args: [G; IN_320] = [__v_11, __v_13]; 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 __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_11, __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_14: G = __r_arr[0];
-        let __ret: [G; OUT_320] = [__v_14];
-        record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_323] = [__v_14];
+        record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_321: usize = 1;
-const IN_321: usize = 1;
-const OUT_321: usize = 1;
-fn aiur_fn_321(
-  inp: [G; IN_321],
+const INPUT_SIZE_324: usize = 1;
+const IN_324: usize = 1;
+const OUT_324: usize = 1;
+fn aiur_fn_324(
+  inp: [G; IN_324],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_321], ExecError> {
+) -> Result<[G; OUT_324], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !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_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];
@@ -29992,65 +29435,65 @@ fn aiur_fn_321(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_321] = [__v_12];
-        record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_324] = [__v_12];
+        record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_321] = [__v_12];
-        record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_324] = [__v_12];
+        record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_322: usize = 2;
-const IN_322: usize = 2;
-const OUT_322: usize = 2;
-fn aiur_fn_322(
-  inp: [G; IN_322],
+const INPUT_SIZE_325: usize = 2;
+const IN_325: usize = 2;
+const OUT_325: usize = 2;
+fn aiur_fn_325(
+  inp: [G; IN_325],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_322], ExecError> {
+) -> Result<[G; OUT_325], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __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_317] = { let __args: [G; IN_317] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2, __v_1]; 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __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 __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_3]; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_5]; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !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_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_321] = { let __args: [G; IN_321] = [__v_1]; 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 __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__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_8: G = __r_arr[0];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_322] = [__v_2, __v_3];
-        record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_325] = [__v_2, __v_3];
+        record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_9, __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 __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_9, __v_1]; 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_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_322] = [__v_2, __v_3];
-        record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_325] = [__v_2, __v_3];
+        record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -30060,75 +29503,75 @@ fn aiur_fn_322(
   })
 }
 
-const INPUT_SIZE_323: usize = 2;
-const IN_323: usize = 2;
-const OUT_323: usize = 1;
-fn aiur_fn_323(
-  inp: [G; IN_323],
+const INPUT_SIZE_326: usize = 2;
+const IN_326: usize = 2;
+const OUT_326: usize = 1;
+fn aiur_fn_326(
+  inp: [G; IN_326],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_323], ExecError> {
+) -> Result<[G; OUT_326], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
-    let __ret: [G; OUT_323] = [__v_2];
-    record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_326] = [__v_2];
+    record.function_queries[326].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 = 1;
-fn aiur_fn_324(
-  inp: [G; IN_324],
+const INPUT_SIZE_327: usize = 2;
+const IN_327: usize = 2;
+const OUT_327: usize = 1;
+fn aiur_fn_327(
+  inp: [G; IN_327],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_324], ExecError> {
+) -> Result<[G; OUT_327], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
-    let __ret: [G; OUT_324] = [__v_3];
-    record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_327] = [__v_3];
+    record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_325: usize = 2;
-const IN_325: usize = 2;
-const OUT_325: usize = 1;
-fn aiur_fn_325(
-  inp: [G; IN_325],
+const INPUT_SIZE_328: usize = 2;
+const IN_328: usize = 2;
+const OUT_328: usize = 1;
+fn aiur_fn_328(
+  inp: [G; IN_328],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_325], ExecError> {
+) -> Result<[G; OUT_328], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_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];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_325] = [__v_0];
-        record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_328] = [__v_0];
+        record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_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 __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_3]; 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_4: G = __r_arr[0];
-        let __ret: [G; OUT_325] = [__v_4];
-        record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_328] = [__v_4];
+        record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -30138,19 +29581,19 @@ fn aiur_fn_325(
   })
 }
 
-const INPUT_SIZE_326: usize = 2;
-const IN_326: usize = 2;
-const OUT_326: usize = 1;
-fn aiur_fn_326(
-  inp: [G; IN_326],
+const INPUT_SIZE_329: usize = 2;
+const IN_329: usize = 2;
+const OUT_329: usize = 1;
+fn aiur_fn_329(
+  inp: [G; IN_329],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_326], ExecError> {
+) -> Result<[G; OUT_329], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_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];
     match __v_2.as_canonical_u64() {
       1u64 => {
@@ -30167,8 +29610,8 @@ fn aiur_fn_326(
         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_326] = [__v_15];
-        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_329] = [__v_15];
+        record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -30185,30 +29628,30 @@ fn aiur_fn_326(
         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_322] = { let __args: [G; IN_322] = [__v_1, __v_15]; 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 __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __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 __v_17: G = __r_arr[1];
-        let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_0]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_18]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_18]; 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_16]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_16]; 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_326] = { let __args: [G; IN_326] = [__v_19, __v_20]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_17]; 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 __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_17]; 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_22: G = __r_arr[0];
         match __v_22.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_326] = [__v_21];
-            record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_329] = [__v_21];
+            record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_21]; 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_23: G = __r_arr[0];
-            let __ret: [G; OUT_326] = [__v_23];
-            record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_329] = [__v_23];
+            record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30223,15 +29666,15 @@ fn aiur_fn_326(
   })
 }
 
-const INPUT_SIZE_327: usize = 16;
-const IN_327: usize = 16;
-const OUT_327: usize = 8;
-fn aiur_fn_327(
-  inp: [G; IN_327],
+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_327], ExecError> {
+) -> 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];
@@ -30257,21 +29700,21 @@ fn aiur_fn_327(
     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_327] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_328: usize = 16;
-const IN_328: usize = 16;
-const OUT_328: usize = 8;
-fn aiur_fn_328(
-  inp: [G; IN_328],
+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_328], ExecError> {
+) -> Result<[G; OUT_331], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30297,21 +29740,21 @@ fn aiur_fn_328(
     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_328] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_329: usize = 16;
-const IN_329: usize = 16;
-const OUT_329: usize = 8;
-fn aiur_fn_329(
-  inp: [G; IN_329],
+const INPUT_SIZE_332: usize = 16;
+const IN_332: usize = 16;
+const OUT_332: usize = 8;
+fn aiur_fn_332(
+  inp: [G; IN_332],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_329], ExecError> {
+) -> Result<[G; OUT_332], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30337,21 +29780,21 @@ fn aiur_fn_329(
     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_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));
+    let __ret: [G; OUT_332] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_330: usize = 2;
-const IN_330: usize = 2;
-const OUT_330: usize = 1;
-fn aiur_fn_330(
-  inp: [G; IN_330],
+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_330], ExecError> {
+) -> Result<[G; OUT_333], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30371,8 +29814,8 @@ fn aiur_fn_330(
         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_330] = [__v_14];
-        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_333] = [__v_14];
+        record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -30392,13 +29835,13 @@ fn aiur_fn_330(
             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_330] = [__v_24];
-            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_333] = [__v_24];
+            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_327] = { let __args: [G; IN_327] = [__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[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 __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];
@@ -30407,11 +29850,11 @@ fn aiur_fn_330(
             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_330] = { let __args: [G; IN_330] = [__v_11, __v_21]; 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 __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_330] = [__v_32];
-            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_333] = [__v_32];
+            record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30426,15 +29869,15 @@ fn aiur_fn_330(
   })
 }
 
-const INPUT_SIZE_331: usize = 2;
-const IN_331: usize = 2;
-const OUT_331: usize = 1;
-fn aiur_fn_331(
-  inp: [G; IN_331],
+const INPUT_SIZE_334: usize = 2;
+const IN_334: usize = 2;
+const OUT_334: usize = 1;
+fn aiur_fn_334(
+  inp: [G; IN_334],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_331], ExecError> {
+) -> Result<[G; OUT_334], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30451,8 +29894,8 @@ fn aiur_fn_331(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_331] = [__v_1];
-        record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_334] = [__v_1];
+        record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -30469,13 +29912,13 @@ fn aiur_fn_331(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_331] = [__v_0];
-            record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_328] = { let __args: [G; IN_328] = [__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[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 __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];
@@ -30484,11 +29927,11 @@ fn aiur_fn_331(
             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_331] = { let __args: [G; IN_331] = [__v_11, __v_21]; 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 __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_331] = [__v_32];
-            record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_334] = [__v_32];
+            record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30503,15 +29946,15 @@ fn aiur_fn_331(
   })
 }
 
-const INPUT_SIZE_332: usize = 2;
-const IN_332: usize = 2;
-const OUT_332: usize = 1;
-fn aiur_fn_332(
-  inp: [G; IN_332],
+const INPUT_SIZE_335: usize = 2;
+const IN_335: usize = 2;
+const OUT_335: usize = 1;
+fn aiur_fn_335(
+  inp: [G; IN_335],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_332], ExecError> {
+) -> Result<[G; OUT_335], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30528,8 +29971,8 @@ fn aiur_fn_332(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_332] = [__v_1];
-        record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_335] = [__v_1];
+        record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -30546,13 +29989,13 @@ fn aiur_fn_332(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_332] = [__v_0];
-            record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_335] = [__v_0];
+            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__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[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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -30561,11 +30004,11 @@ 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; 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 __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !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_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));
+            let __ret: [G; OUT_335] = [__v_32];
+            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30580,15 +30023,15 @@ fn aiur_fn_332(
   })
 }
 
-const INPUT_SIZE_333: usize = 2;
-const IN_333: usize = 2;
-const OUT_333: usize = 1;
-fn aiur_fn_333(
-  inp: [G; IN_333],
+const INPUT_SIZE_336: usize = 2;
+const IN_336: usize = 2;
+const OUT_336: usize = 1;
+fn aiur_fn_336(
+  inp: [G; IN_336],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_333], ExecError> {
+) -> Result<[G; OUT_336], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30605,25 +30048,25 @@ fn aiur_fn_333(
     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_326] = { let __args: [G; IN_326] = [__v_14, __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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_14, __v_1]; 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_15]; 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_16: G = __r_arr[0];
-    let __ret: [G; OUT_333] = [__v_16];
-    record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_336] = [__v_16];
+    record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_334: usize = 2;
-const IN_334: usize = 2;
-const OUT_334: usize = 1;
-fn aiur_fn_334(
-  inp: [G; IN_334],
+const INPUT_SIZE_337: usize = 2;
+const IN_337: usize = 2;
+const OUT_337: usize = 1;
+fn aiur_fn_337(
+  inp: [G; IN_337],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_334], ExecError> {
+) -> Result<[G; OUT_337], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30640,25 +30083,25 @@ fn aiur_fn_334(
     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_326] = { let __args: [G; IN_326] = [__v_14, __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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_14, __v_1]; 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_15]; 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_16: G = __r_arr[0];
-    let __ret: [G; OUT_334] = [__v_16];
-    record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_337] = [__v_16];
+    record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_335: usize = 3;
-const IN_335: usize = 3;
-const OUT_335: usize = 2;
-fn aiur_fn_335(
-  inp: [G; IN_335],
+const INPUT_SIZE_338: usize = 3;
+const IN_338: usize = 3;
+const OUT_338: usize = 2;
+fn aiur_fn_338(
+  inp: [G; IN_338],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_335], ExecError> {
+) -> Result<[G; OUT_338], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30671,28 +30114,28 @@ fn aiur_fn_335(
       1u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_335] = [__v_6, __v_7];
-        record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_338] = [__v_6, __v_7];
+        record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_4]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_335] = [__v_7, __v_2];
-            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_338] = [__v_7, __v_2];
+            record.function_queries[338].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_335] = { let __args: [G; IN_335] = [__v_0, __v_5, __v_8]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0, __v_5, __v_8]; 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_335] = [__v_9, __v_10];
-            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_338] = [__v_9, __v_10];
+            record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30707,15 +30150,15 @@ fn aiur_fn_335(
   })
 }
 
-const INPUT_SIZE_336: usize = 3;
-const IN_336: usize = 3;
-const OUT_336: usize = 1;
-fn aiur_fn_336(
-  inp: [G; IN_336],
+const INPUT_SIZE_339: usize = 3;
+const IN_339: usize = 3;
+const OUT_339: usize = 1;
+fn aiur_fn_339(
+  inp: [G; IN_339],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_336], ExecError> {
+) -> Result<[G; OUT_339], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30739,16 +30182,16 @@ fn aiur_fn_336(
         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_336] = [__v_18];
-        record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_339] = [__v_18];
+        record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0]; 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_13]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__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 __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_14]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_14]; 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_15: G = __r_arr[0];
         let __v_16: G = G::from_u64(2);
         let __v_17: G = G::from_u64(1);
@@ -30759,8 +30202,8 @@ fn aiur_fn_336(
         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_336] = [__v_24];
-        record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_339] = [__v_24];
+        record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -30770,15 +30213,15 @@ fn aiur_fn_336(
   })
 }
 
-const INPUT_SIZE_337: usize = 2;
-const IN_337: usize = 2;
-const OUT_337: usize = 1;
-fn aiur_fn_337(
-  inp: [G; IN_337],
+const INPUT_SIZE_340: usize = 2;
+const IN_340: usize = 2;
+const OUT_340: usize = 1;
+fn aiur_fn_340(
+  inp: [G; IN_340],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_337], ExecError> {
+) -> Result<[G; OUT_340], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30791,67 +30234,67 @@ fn aiur_fn_337(
       7u64 => {
         match __v_3.as_canonical_u64() {
           0u64 => {
-            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 __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_6: G = __r_arr[0];
             let __v_7: G = G::from_u64(0);
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_1, __v_7]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6, __v_1, __v_7]; 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            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 __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_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_10, __v_1, __v_11]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_10, __v_1, __v_11]; 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_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_336] = { let __args: [G; IN_336] = [__v_4, __v_9, __v_13]; 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 __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_9, __v_13]; 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_14: G = __r_arr[0];
-                    let __ret: [G; OUT_337] = [__v_14];
-                    record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_340] = [__v_14];
+                    record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __ret: [G; OUT_337] = [__v_0];
-                    record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_340] = [__v_0];
+                    record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_337] = [__v_0];
-                record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_340] = [__v_0];
+                record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_337] = [__v_0];
-            record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_340] = [__v_0];
+            record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_337] = [__v_0];
-        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_340] = [__v_0];
+        record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_338: usize = 2;
-const IN_338: usize = 2;
-const OUT_338: usize = 2;
-fn aiur_fn_338(
-  inp: [G; IN_338],
+const INPUT_SIZE_341: usize = 2;
+const IN_341: usize = 2;
+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_338], ExecError> {
+) -> 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];
@@ -30865,8 +30308,8 @@ fn aiur_fn_338(
         match __v_3.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_338] = [__v_6, __v_4];
-            record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_341] = [__v_6, __v_4];
+            record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30874,18 +30317,18 @@ fn aiur_fn_338(
             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_338] = [__v_6, __v_9];
-            record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_341] = [__v_6, __v_9];
+            record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
+        let __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
@@ -30893,8 +30336,8 @@ fn aiur_fn_338(
             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_338] = [__v_9, __v_12];
-            record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_341] = [__v_9, __v_12];
+            record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -30902,8 +30345,8 @@ fn aiur_fn_338(
             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_338] = [__v_9, __v_12];
-            record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_341] = [__v_9, __v_12];
+            record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30912,11 +30355,11 @@ fn aiur_fn_338(
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_4, __v_1]; 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 __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_4, __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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __ret: [G; OUT_338] = [__v_6, __v_7];
-        record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_341] = [__v_6, __v_7];
+        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -30924,23 +30367,23 @@ fn aiur_fn_338(
         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_338] = [__v_6, __v_9];
-        record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_341] = [__v_6, __v_9];
+        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_339: usize = 3;
-const IN_339: usize = 3;
-const OUT_339: usize = 2;
-fn aiur_fn_339(
-  inp: [G; IN_339],
+const INPUT_SIZE_342: usize = 3;
+const IN_342: usize = 3;
+const OUT_342: usize = 2;
+fn aiur_fn_342(
+  inp: [G; IN_342],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_339], ExecError> {
+) -> Result<[G; OUT_342], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30952,24 +30395,24 @@ fn aiur_fn_339(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __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 __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_7, __v_8]; 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_9: G = __r_arr[0];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_2]; 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_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_305] = { let __args: [G; IN_305] = [__v_11]; 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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_11]; 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_13: G = __r_arr[0];
-                let __ret: [G; OUT_339] = [__v_12, __v_13];
-                record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_342] = [__v_12, __v_13];
+                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -30977,8 +30420,8 @@ fn aiur_fn_339(
                 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_339] = [__v_12, __v_15];
-                record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_342] = [__v_12, __v_15];
+                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -30988,8 +30431,8 @@ fn aiur_fn_339(
             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_339] = [__v_10, __v_13];
-            record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_342] = [__v_10, __v_13];
+            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -31002,217 +30445,217 @@ fn aiur_fn_339(
         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_339] = [__v_7, __v_10];
-        record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_342] = [__v_7, __v_10];
+        record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_340: usize = 1;
-const IN_340: usize = 1;
-const OUT_340: usize = 1;
-fn aiur_fn_340(
-  inp: [G; IN_340],
+const INPUT_SIZE_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_340], ExecError> {
+) -> Result<[G; OUT_343], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = 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_340] = [__v_4];
-    record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_343] = [__v_4];
+    record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_341: usize = 1;
-const IN_341: usize = 1;
-const OUT_341: usize = 1;
-fn aiur_fn_341(
-  inp: [G; IN_341],
+const INPUT_SIZE_344: usize = 1;
+const IN_344: usize = 1;
+const OUT_344: usize = 1;
+fn aiur_fn_344(
+  inp: [G; IN_344],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_341], ExecError> {
+) -> Result<[G; OUT_344], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    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 __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_1: G = __r_arr[0];
-    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 __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
+    let __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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_3]; 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+    let __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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_5]; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
+    let __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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __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_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __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_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_11]; 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_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 __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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_13]; 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_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+    let __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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
-    let __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 __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_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
-    let __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 __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_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
-    let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+    let __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_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_22: G = __r_arr[0];
-    let __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 __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_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_23]; 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_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
+    let __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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_25]; 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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
+    let __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_27: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_27]; 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_28: G = __r_arr[0];
-    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+    let __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_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_29]; 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_30: G = __r_arr[0];
-    let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+    let __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_31: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_31]; 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_32: G = __r_arr[0];
-    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } };
+    let __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_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_33]; 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_34: G = __r_arr[0];
-    let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } };
+    let __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_35: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_35]; 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_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+    let __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_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_37]; 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_38: G = __r_arr[0];
-    let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+    let __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_39: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_39]; 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_40: G = __r_arr[0];
-    let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = []; 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_41: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_41]; 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_42: G = __r_arr[0];
-    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
+    let __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_43: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_43]; 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_44: G = __r_arr[0];
-    let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } };
+    let __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_45: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_45]; 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_46: G = __r_arr[0];
-    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } };
+    let __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_47: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_47]; 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_48: G = __r_arr[0];
-    let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } };
+    let __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_49: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_49]; 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_50: G = __r_arr[0];
-    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+    let __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_51: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_51]; 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_52: G = __r_arr[0];
-    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+    let __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_53: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_53]; 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_54: G = __r_arr[0];
-    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+    let __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_55: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_55]; 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_56: G = __r_arr[0];
-    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+    let __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_57: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_57]; 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_58: G = __r_arr[0];
-    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+    let __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_59: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_59]; 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_60: G = __r_arr[0];
-    let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__args, record, io_buffer, __cu)? } };
+    let __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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_61]; 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_62: G = __r_arr[0];
-    let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+    let __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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_63]; 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_64: G = __r_arr[0];
-    let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+    let __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_65: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_65]; 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_66: G = __r_arr[0];
-    let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+    let __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_67: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_67]; 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_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+    let __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_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_69]; 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_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+    let __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_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_71]; 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_72: G = __r_arr[0];
-    let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+    let __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_73: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_73]; 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_74: G = __r_arr[0];
-    let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+    let __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_75: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_75]; 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_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+    let __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_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_77]; 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_78: G = __r_arr[0];
-    let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
+    let __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_79: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_79]; 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_80: G = __r_arr[0];
-    let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
+    let __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_81: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_81]; 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_82: G = __r_arr[0];
-    let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
+    let __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_83: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_83]; 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_84: G = __r_arr[0];
-    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+    let __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_85: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_85]; 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_86: G = __r_arr[0];
     let __v_87: G = (__v_84 + __v_86);
     let __v_88: G = (__v_82 + __v_87);
@@ -31256,36 +30699,36 @@ fn aiur_fn_341(
     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_341] = [__v_128];
-    record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_344] = [__v_128];
+    record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_342: usize = 5;
-const IN_342: usize = 5;
-const OUT_342: usize = 2;
-fn aiur_fn_342(
-  inp: [G; IN_342],
+const INPUT_SIZE_345: usize = 5;
+const IN_345: usize = 5;
+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_342], ExecError> {
+) -> Result<[G; OUT_345], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; 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 __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 __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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_6]; 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
+    let __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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_8]; 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
@@ -31298,33 +30741,33 @@ fn aiur_fn_342(
             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_342] = [__v_12, __v_16];
-            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_345] = [__v_12, __v_16];
+            record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_13, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_13, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_14, __v_4]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_14, __v_4]; 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_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_785] = { let __args: [G; IN_785] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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_305] = { let __args: [G; IN_305] = [__v_16]; 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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_16]; 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_20: G = __r_arr[0];
-                let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_20]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_20]; 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_21: G = __r_arr[0];
-                let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_21, __v_18]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_21, __v_18]; 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_22: G = __r_arr[0];
-                let __ret: [G; OUT_342] = [__v_19, __v_22];
-                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_345] = [__v_19, __v_22];
+                record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -31333,8 +30776,8 @@ fn aiur_fn_342(
                 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_342] = [__v_17, __v_21];
-                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_345] = [__v_17, __v_21];
+                record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -31356,33 +30799,33 @@ fn aiur_fn_342(
                 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_342] = [__v_12, __v_16];
-                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_345] = [__v_12, __v_16];
+                record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_12: G = G::from_u64(0);
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
-                let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_13, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_13, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0];
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_14, __v_4]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_14, __v_4]; 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_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_785] = { let __args: [G; IN_785] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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_313] = { let __args: [G; IN_313] = [__v_16]; 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 __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_16]; 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_20: G = __r_arr[0];
-                    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_20]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_20]; 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_21: G = __r_arr[0];
-                    let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_21, __v_18]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_21, __v_18]; 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_22: G = __r_arr[0];
-                    let __ret: [G; OUT_342] = [__v_19, __v_22];
-                    record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_345] = [__v_19, __v_22];
+                    record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -31391,8 +30834,8 @@ fn aiur_fn_342(
                     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_342] = [__v_17, __v_21];
-                    record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_345] = [__v_17, __v_21];
+                    record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -31403,11 +30846,11 @@ fn aiur_fn_342(
             }
           },
           0u64 => {
-            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_1, __v_5, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_1, __v_5, __v_2, __v_3, __v_4]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_342] = [__v_10, __v_11];
-            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_345] = [__v_10, __v_11];
+            record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -31422,15 +30865,15 @@ fn aiur_fn_342(
   })
 }
 
-const INPUT_SIZE_343: usize = 6;
-const IN_343: usize = 6;
-const OUT_343: usize = 2;
-fn aiur_fn_343(
-  inp: [G; IN_343],
+const INPUT_SIZE_346: usize = 6;
+const IN_346: usize = 6;
+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_343], ExecError> {
+) -> Result<[G; OUT_346], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -31447,44 +30890,44 @@ fn aiur_fn_343(
         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_343] = [__v_8, __v_12];
-        record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_346] = [__v_8, __v_12];
+        record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_9, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_9, __v_3, __v_4, __v_5]; 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_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_12, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_12, __v_3, __v_4, __v_5]; 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_10, __v_5]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_10, __v_5]; 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_5]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_13, __v_5]; 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_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_344] = { let __args: [G; IN_344] = [__v_0, __v_15, __v_17, __v_5]; 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 __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_15, __v_17, __v_5]; 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_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_785] = { let __args: [G; IN_785] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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_404] = { let __args: [G; IN_404] = [__v_19, __v_21]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_19, __v_21]; 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_23: G = __r_arr[0];
-                    let __ret: [G; OUT_343] = [__v_22, __v_23];
-                    record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_346] = [__v_22, __v_23];
+                    record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
@@ -31493,8 +30936,8 @@ fn aiur_fn_343(
                     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_343] = [__v_20, __v_24];
-                    record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_346] = [__v_20, __v_24];
+                    record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -31508,8 +30951,8 @@ fn aiur_fn_343(
                 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_343] = [__v_18, __v_22];
-                record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_346] = [__v_18, __v_22];
+                record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -31520,8 +30963,8 @@ fn aiur_fn_343(
             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_343] = [__v_18, __v_22];
-            record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_346] = [__v_18, __v_22];
+            record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -31533,265 +30976,265 @@ fn aiur_fn_343(
   })
 }
 
-const INPUT_SIZE_344: usize = 4;
-const IN_344: usize = 4;
-const OUT_344: usize = 2;
-fn aiur_fn_344(
-  inp: [G; IN_344],
+const INPUT_SIZE_347: usize = 4;
+const IN_347: usize = 4;
+const OUT_347: usize = 2;
+fn aiur_fn_347(
+  inp: [G; IN_347],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_344], ExecError> {
+) -> Result<[G; OUT_347], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_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 __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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_4]; 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_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_307] = { let __args: [G; IN_307] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1, __v_2]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_7]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_7]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_8]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_344] = [__v_6, __v_9];
-        record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_347] = [__v_6, __v_9];
+        record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_6]; 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_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_311] = { let __args: [G; IN_311] = [__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 __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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_9]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_9]; 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_10]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_10]; 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_11: G = __r_arr[0];
-            let __ret: [G; OUT_344] = [__v_8, __v_11];
-            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_347] = [__v_8, __v_11];
+            record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+            let __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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_8]; 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_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_317] = { let __args: [G; IN_317] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_1, __v_2]; 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_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_11]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_11]; 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_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_12]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_12]; 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_13: G = __r_arr[0];
-                let __ret: [G; OUT_344] = [__v_10, __v_13];
-                record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_347] = [__v_10, __v_13];
+                record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
+                let __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_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_10]; 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_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_323] = { let __args: [G; IN_323] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_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_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_13]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__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 __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_14]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_14]; 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_15: G = __r_arr[0];
-                    let __ret: [G; OUT_344] = [__v_12, __v_15];
-                    record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_347] = [__v_12, __v_15];
+                    record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+                    let __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_126] = { let __args: [G; IN_126] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_12]; 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_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_324] = { let __args: [G; IN_324] = [__v_1, __v_2]; 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 __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_15: G = __r_arr[0];
-                        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_15]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_15]; 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_16: G = __r_arr[0];
-                        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_16]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_16]; 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_17: G = __r_arr[0];
-                        let __ret: [G; OUT_344] = [__v_14, __v_17];
-                        record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_347] = [__v_14, __v_17];
+                        record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
+                        let __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_126] = { let __args: [G; IN_126] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_14]; 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_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_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 __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_17: G = __r_arr[0];
-                            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_17]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_17]; 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_18: G = __r_arr[0];
-                            let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_18]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_18]; 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_19: G = __r_arr[0];
-                            let __ret: [G; OUT_344] = [__v_16, __v_19];
-                            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_347] = [__v_16, __v_19];
+                            record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
-                            let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+                            let __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_16: G = __r_arr[0];
-                            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_16]; 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_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_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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_1, __v_2]; 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_19: G = __r_arr[0];
-                                let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_19]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__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_340] = { let __args: [G; IN_340] = [__v_20]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_20]; 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_21: G = __r_arr[0];
-                                let __ret: [G; OUT_344] = [__v_18, __v_21];
-                                record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_347] = [__v_18, __v_21];
+                                record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+                                let __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_18: G = __r_arr[0];
-                                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_18]; 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_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_330] = { let __args: [G; IN_330] = [__v_1, __v_2]; 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 __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_21: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_21]; 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_22: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_22]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_22]; 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_23: G = __r_arr[0];
-                                    let __ret: [G; OUT_344] = [__v_20, __v_23];
-                                    record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_347] = [__v_20, __v_23];
+                                    record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   0u64 => {
-                                    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+                                    let __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_20: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_20]; 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_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_331] = { let __args: [G; IN_331] = [__v_1, __v_2]; 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 __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_23: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_23]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_23]; 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_24: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_24]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_24]; 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_25: G = __r_arr[0];
-                                        let __ret: [G; OUT_344] = [__v_22, __v_25];
-                                        record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_347] = [__v_22, __v_25];
+                                        record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       0u64 => {
-                                        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
+                                        let __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_22: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
                                         let __v_23: G = __r_arr[0];
                                         match __v_23.as_canonical_u64() {
                                           1u64 => {
                                             let __v_24: G = G::from_u64(1);
-                                            let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+                                            let __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_25: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_25]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_25]; 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_26: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_26]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_26]; 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_27: G = __r_arr[0];
-                                            let __ret: [G; OUT_344] = [__v_24, __v_27];
-                                            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_347] = [__v_24, __v_27];
+                                            record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           0u64 => {
-                                            let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+                                            let __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_24: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_24]; 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_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_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 __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_27: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_27]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_27]; 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_28: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_28]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_28]; 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_29: G = __r_arr[0];
-                                                let __ret: [G; OUT_344] = [__v_26, __v_29];
-                                                record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_347] = [__v_26, __v_29];
+                                                record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               0u64 => {
-                                                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+                                                let __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_26: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_26]; 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_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_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 __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !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_29: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_29]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_29]; 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_30: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_30]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_30]; 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_31: G = __r_arr[0];
-                                                    let __ret: [G; OUT_344] = [__v_28, __v_31];
-                                                    record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_347] = [__v_28, __v_31];
+                                                    record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                   0u64 => {
-                                                    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+                                                    let __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_28: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_28]; 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_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_233] = { let __args: [G; IN_233] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_1, __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_31: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_31, __v_3]; 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 __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_31, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
                                                         let __v_32: G = __r_arr[0];
-                                                        let __ret: [G; OUT_344] = [__v_30, __v_32];
-                                                        record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                        let __ret: [G; OUT_347] = [__v_30, __v_32];
+                                                        record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                         return Ok(__ret);
                                                       },
                                                       0u64 => {
-                                                        let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+                                                        let __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_30: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_30]; 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_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_312] = { let __args: [G; IN_312] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_1, __v_2]; 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_33: G = __r_arr[0];
-                                                            let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_33, __v_3]; 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 __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_33, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
                                                             let __v_34: G = __r_arr[0];
-                                                            let __ret: [G; OUT_344] = [__v_32, __v_34];
-                                                            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            let __ret: [G; OUT_347] = [__v_32, __v_34];
+                                                            record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                             return Ok(__ret);
                                                           },
                                                           0u64 => {
@@ -31800,8 +31243,8 @@ fn aiur_fn_344(
                                                             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_344] = [__v_32, __v_36];
-                                                            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            let __ret: [G; OUT_347] = [__v_32, __v_36];
+                                                            record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                             return Ok(__ret);
                                                           },
                                                           _ => {
@@ -31876,26 +31319,26 @@ fn aiur_fn_344(
   })
 }
 
-const INPUT_SIZE_345: usize = 2;
-const IN_345: usize = 2;
-const OUT_345: usize = 1;
-fn aiur_fn_345(
-  inp: [G; IN_345],
+const INPUT_SIZE_348: usize = 2;
+const IN_348: usize = 2;
+const OUT_348: usize = 1;
+fn aiur_fn_348(
+  inp: [G; IN_348],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_345], ExecError> {
+) -> Result<[G; OUT_348], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
   0u64 => {
-    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 __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = []; 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_2: G = __r_arr[0];
     break '__mc_0 [__v_2];
   },
   _ => {
-    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 __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];
   },
@@ -31903,7 +31346,7 @@ fn aiur_fn_345(
  };
     let __v_2: G = __mc_out___mc_0[0];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_2, __v_1, __v_3]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2, __v_1, __v_3]; 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -31914,8 +31357,8 @@ fn aiur_fn_345(
         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_345] = [__v_11];
-        record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_348] = [__v_11];
+        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -31928,8 +31371,8 @@ fn aiur_fn_345(
             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_345] = [__v_12];
-            record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_348] = [__v_12];
+            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -31950,8 +31393,8 @@ fn aiur_fn_345(
             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_345] = [__v_22];
-            record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_348] = [__v_22];
+            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -31963,15 +31406,15 @@ fn aiur_fn_345(
   })
 }
 
-const INPUT_SIZE_346: usize = 1;
-const IN_346: usize = 1;
-const OUT_346: usize = 1;
-fn aiur_fn_346(
-  inp: [G; IN_346],
+const INPUT_SIZE_349: usize = 1;
+const IN_349: usize = 1;
+const OUT_349: usize = 1;
+fn aiur_fn_349(
+  inp: [G; IN_349],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_346], ExecError> {
+) -> Result<[G; OUT_349], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -31988,8 +31431,8 @@ fn aiur_fn_346(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_346] = [__v_11];
-        record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_349] = [__v_11];
+        record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -32002,8 +31445,8 @@ fn aiur_fn_346(
         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_346] = [__v_19];
-        record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_349] = [__v_19];
+        record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -32013,21 +31456,21 @@ fn aiur_fn_346(
   })
 }
 
-const INPUT_SIZE_347: usize = 4;
-const IN_347: usize = 4;
-const OUT_347: usize = 2;
-fn aiur_fn_347(
-  inp: [G; IN_347],
+const INPUT_SIZE_350: usize = 4;
+const IN_350: usize = 4;
+const OUT_350: usize = 2;
+fn aiur_fn_350(
+  inp: [G; IN_350],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_347], ExecError> {
+) -> Result<[G; OUT_350], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_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 };
@@ -32038,20 +31481,20 @@ fn aiur_fn_347(
         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_347] = [__v_7, __v_11];
-        record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_350] = [__v_7, __v_11];
+        record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_10, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_10, __v_1, __v_2, __v_3]; 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_11, __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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -32062,14 +31505,14 @@ fn aiur_fn_347(
             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_347] = [__v_15, __v_19];
-            record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_350] = [__v_15, __v_19];
+            record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_14, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_14, __v_1, __v_2, __v_3]; 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_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_15, __v_3]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_15, __v_3]; 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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
             match __v_16.as_canonical_u64() {
@@ -32079,14 +31522,14 @@ fn aiur_fn_347(
                 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_347] = [__v_18, __v_22];
-                record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_350] = [__v_18, __v_22];
+                record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_13, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_13, __v_1, __v_2, __v_3]; 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_18: G = __r_arr[0];
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_18, __v_3]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_18, __v_3]; 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_19: G = __r_arr[0];
                 let __v_20: G = __r_arr[1];
                 match __v_19.as_canonical_u64() {
@@ -32096,8 +31539,8 @@ fn aiur_fn_347(
                     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_347] = [__v_21, __v_25];
-                    record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_350] = [__v_21, __v_25];
+                    record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
@@ -32114,15 +31557,15 @@ fn aiur_fn_347(
                     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_326] = { let __args: [G; IN_326] = [__v_33, __v_20]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_33, __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_34: G = __r_arr[0];
-                    let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_17, __v_34]; 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 __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_17, __v_34]; 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_35: G = __r_arr[0];
                     let __v_36: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_35]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_35]; 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_37: G = __r_arr[0];
-                    let __ret: [G; OUT_347] = [__v_36, __v_37];
-                    record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_350] = [__v_36, __v_37];
+                    record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -32147,19 +31590,19 @@ fn aiur_fn_347(
   })
 }
 
-const INPUT_SIZE_348: usize = 2;
-const IN_348: usize = 2;
-const OUT_348: usize = 3;
-fn aiur_fn_348(
-  inp: [G; IN_348],
+const INPUT_SIZE_351: usize = 2;
+const IN_351: usize = 2;
+const OUT_351: usize = 3;
+fn aiur_fn_351(
+  inp: [G; IN_351],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_348], ExecError> {
+) -> Result<[G; OUT_351], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_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 };
@@ -32169,15 +31612,15 @@ fn aiur_fn_348(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __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 __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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = G::from_u64(2);
             let __v_13: G = (__v_11 - __v_12);
@@ -32185,13 +31628,13 @@ fn aiur_fn_348(
               0u64 => {
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(0);
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
                 let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
-                let __ret: [G; OUT_348] = [__v_14, __v_16, __v_18];
-                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_351] = [__v_14, __v_16, __v_18];
+                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32204,8 +31647,8 @@ fn aiur_fn_348(
                 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_348] = [__v_14, __v_18, __v_22];
-                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_351] = [__v_14, __v_18, __v_22];
+                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -32244,7 +31687,7 @@ fn aiur_fn_348(
             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_126] = { let __args: [G; IN_126] = [__v_8, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_8, __v_43]; 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_44: G = __r_arr[0];
             match __v_44.as_canonical_u64() {
               0u64 => {
@@ -32257,12 +31700,12 @@ fn aiur_fn_348(
                 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_348] = [__v_45, __v_49, __v_53];
-                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_351] = [__v_45, __v_49, __v_53];
+                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
                 let __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 };
@@ -32277,15 +31720,15 @@ fn aiur_fn_348(
                     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_348] = [__v_48, __v_52, __v_56];
-                    record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_351] = [__v_48, __v_52, __v_56];
+                    record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_48: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                     let __v_49: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_49]; 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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_49]; 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_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 };
@@ -32295,11 +31738,11 @@ fn aiur_fn_348(
                     let __v_55: G = __loaded[3];
                     match __v_52.as_canonical_u64() {
                       2u64 => {
-                        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                         let __v_56: G = __r_arr[0];
-                        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__args, record, io_buffer, __cu)? } };
+                        let __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_57: G = __r_arr[0];
-                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_56, __v_57]; 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_58: G = __r_arr[0];
                         match __v_58.as_canonical_u64() {
                           0u64 => {
@@ -32312,12 +31755,12 @@ fn aiur_fn_348(
                             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_348] = [__v_59, __v_63, __v_67];
-                            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_351] = [__v_59, __v_63, __v_67];
+                            record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           1u64 => {
-                            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_51]; 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_59: G = __r_arr[0];
                             let __v_60: G = G::from_u64(1);
                             let __v_61: G = (__v_59 - __v_60);
@@ -32325,13 +31768,13 @@ fn aiur_fn_348(
                               0u64 => {
                                 let __v_62: G = G::from_u64(1);
                                 let __v_63: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_51, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_51, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                                 let __v_64: G = __r_arr[0];
                                 let __v_65: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                                 let __v_66: G = __r_arr[0];
-                                let __ret: [G; OUT_348] = [__v_62, __v_64, __v_66];
-                                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_351] = [__v_62, __v_64, __v_66];
+                                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -32344,8 +31787,8 @@ fn aiur_fn_348(
                                 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_348] = [__v_62, __v_66, __v_70];
-                                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_351] = [__v_62, __v_66, __v_70];
+                                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -32365,8 +31808,8 @@ fn aiur_fn_348(
                         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_348] = [__v_56, __v_60, __v_64];
-                        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_351] = [__v_56, __v_60, __v_64];
+                        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -32396,29 +31839,29 @@ fn aiur_fn_348(
         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_348] = [__v_8, __v_12, __v_16];
-        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_351] = [__v_8, __v_12, __v_16];
+        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_349: usize = 4;
-const IN_349: usize = 4;
-const OUT_349: usize = 2;
-fn aiur_fn_349(
-  inp: [G; IN_349],
+const INPUT_SIZE_352: usize = 4;
+const IN_352: usize = 4;
+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_349], ExecError> {
+) -> Result<[G; OUT_352], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_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 };
@@ -32429,24 +31872,24 @@ fn aiur_fn_349(
         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));
+        let __ret: [G; OUT_352] = [__v_7, __v_11];
+        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(2);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_8, __v_10, __v_1, __v_2, __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 __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_8, __v_10, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_8, __v_12, __v_1, __v_2, __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 __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_8, __v_12, __v_1, __v_2, __v_3]; 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_15: G = __r_arr[0];
         let __v_16: G = __r_arr[1];
         match __v_13.as_canonical_u64() {
@@ -32456,8 +31899,8 @@ fn aiur_fn_349(
             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_349] = [__v_17, __v_21];
-            record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_352] = [__v_17, __v_21];
+            record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
@@ -32468,20 +31911,20 @@ fn aiur_fn_349(
                 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_349] = [__v_17, __v_21];
-                record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_352] = [__v_17, __v_21];
+                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_16, __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 __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_16, __v_14]; 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_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_345] = { let __args: [G; IN_345] = [__v_19, __v_3]; 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 __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_19, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
                 let __v_21: G = __r_arr[0];
-                let __ret: [G; OUT_349] = [__v_20, __v_21];
-                record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_352] = [__v_20, __v_21];
+                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32501,15 +31944,15 @@ fn aiur_fn_349(
   })
 }
 
-const INPUT_SIZE_350: usize = 5;
-const IN_350: usize = 5;
-const OUT_350: usize = 2;
-fn aiur_fn_350(
-  inp: [G; IN_350],
+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_350], ExecError> {
+) -> Result<[G; OUT_353], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -32523,7 +31966,7 @@ fn aiur_fn_350(
     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_347] = { let __args: [G; IN_347] = [__v_11, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_11, __v_2, __v_3, __v_4]; 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];
     match __v_12.as_canonical_u64() {
@@ -32532,8 +31975,8 @@ fn aiur_fn_350(
         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_350] = [__v_14, __v_17];
-        record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_353] = [__v_14, __v_17];
+        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -32547,8 +31990,8 @@ fn aiur_fn_350(
             match __v_15.as_canonical_u64() {
               0u64 => {
                 let __v_18: G = G::from_u64(1);
-                let __ret: [G; OUT_350] = [__v_18, __v_16];
-                record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_353] = [__v_18, __v_16];
+                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32556,8 +31999,8 @@ fn aiur_fn_350(
                 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_350] = [__v_18, __v_21];
-                record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_353] = [__v_18, __v_21];
+                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -32567,8 +32010,8 @@ fn aiur_fn_350(
             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_350] = [__v_18, __v_21];
-            record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_353] = [__v_18, __v_21];
+            record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -32580,60 +32023,60 @@ fn aiur_fn_350(
   })
 }
 
-const INPUT_SIZE_351: usize = 5;
-const IN_351: usize = 5;
-const OUT_351: usize = 2;
-fn aiur_fn_351(
-  inp: [G; IN_351],
+const INPUT_SIZE_354: usize = 5;
+const IN_354: usize = 5;
+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_351], ExecError> {
+) -> Result<[G; OUT_354], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    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 __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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_5]; 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_6: G = __r_arr[0];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2, __v_3, __v_4]; 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __ret: [G; OUT_351] = [__v_7, __v_8];
-        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_354] = [__v_7, __v_8];
+        record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_1, __v_2, __v_3, __v_4]; 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_351] = [__v_9, __v_10];
-            record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_354] = [__v_9, __v_10];
+            record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            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 __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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2, __v_3, __v_4]; 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_11: G = __r_arr[0];
                 let __v_12: G = __r_arr[1];
-                let __ret: [G; OUT_351] = [__v_11, __v_12];
-                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_354] = [__v_11, __v_12];
+                record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -32642,8 +32085,8 @@ fn aiur_fn_351(
                 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_351] = [__v_11, __v_15];
-                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_354] = [__v_11, __v_15];
+                record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32663,21 +32106,21 @@ fn aiur_fn_351(
   })
 }
 
-const INPUT_SIZE_352: usize = 4;
-const IN_352: usize = 4;
-const OUT_352: usize = 2;
-fn aiur_fn_352(
-  inp: [G; IN_352],
+const INPUT_SIZE_355: usize = 4;
+const IN_355: usize = 4;
+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_352], ExecError> {
+) -> Result<[G; OUT_355], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_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 };
@@ -32688,15 +32131,15 @@ fn aiur_fn_352(
         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_352] = [__v_7, __v_11];
-        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_355] = [__v_7, __v_11];
+        record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__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_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 };
@@ -32706,11 +32149,11 @@ fn aiur_fn_352(
         let __v_14: G = __loaded[3];
         match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+            let __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_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_15, __v_16]; 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_17: G = __r_arr[0];
             match __v_17.as_canonical_u64() {
               0u64 => {
@@ -32719,12 +32162,12 @@ fn aiur_fn_352(
                 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_352] = [__v_18, __v_22];
-                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_355] = [__v_18, __v_22];
+                record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_10]; 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_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 };
@@ -32735,15 +32178,15 @@ fn aiur_fn_352(
                     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_352] = [__v_21, __v_25];
-                    record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_767] = { let __args: [G; IN_767] = [__v_10, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_10, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                     let __v_22: G = __r_arr[0];
-                    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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_22]; 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_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 };
@@ -32753,11 +32196,11 @@ fn aiur_fn_352(
                     let __v_28: G = __loaded[3];
                     match __v_25.as_canonical_u64() {
                       2u64 => {
-                        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                         let __v_29: G = __r_arr[0];
-                        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__args, record, io_buffer, __cu)? } };
+                        let __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_30: G = __r_arr[0];
-                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_29, __v_30]; 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_31: G = __r_arr[0];
                         match __v_31.as_canonical_u64() {
                           0u64 => {
@@ -32766,12 +32209,12 @@ fn aiur_fn_352(
                             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_352] = [__v_32, __v_36];
-                            record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_355] = [__v_32, __v_36];
+                            record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           1u64 => {
-                            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_24]; 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_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 };
@@ -32782,19 +32225,19 @@ fn aiur_fn_352(
                                 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_352] = [__v_35, __v_39];
-                                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_355] = [__v_35, __v_39];
+                                record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
                                 let __v_35: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_24, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_24, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                                 let __v_36: G = __r_arr[0];
                                 let __v_37: G = G::from_u64(2);
-                                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_10, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_10, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                                 let __v_38: G = __r_arr[0];
                                 let __v_39: G = G::from_u64(3);
-                                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_10, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_10, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                                 let __v_40: G = __r_arr[0];
                                 let __v_41: G = G::from_u64(0);
                                 let __v_42: G = G::from_u64(0);
@@ -32805,11 +32248,11 @@ fn aiur_fn_352(
                                 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_349] = { let __args: [G; IN_349] = [__v_49, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_49, __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_50: G = __r_arr[0];
                                 let __v_51: G = __r_arr[1];
-                                let __ret: [G; OUT_352] = [__v_50, __v_51];
-                                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_355] = [__v_50, __v_51];
+                                record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -32828,8 +32271,8 @@ fn aiur_fn_352(
                         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_352] = [__v_29, __v_33];
-                        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_355] = [__v_29, __v_33];
+                        record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -32850,8 +32293,8 @@ fn aiur_fn_352(
             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_352] = [__v_15, __v_19];
-            record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_355] = [__v_15, __v_19];
+            record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -32863,84 +32306,84 @@ fn aiur_fn_352(
   })
 }
 
-const INPUT_SIZE_353: usize = 5;
-const IN_353: usize = 5;
-const OUT_353: usize = 2;
-fn aiur_fn_353(
-  inp: [G; IN_353],
+const INPUT_SIZE_356: usize = 5;
+const IN_356: usize = 5;
+const OUT_356: usize = 2;
+fn aiur_fn_356(
+  inp: [G; IN_356],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_353], ExecError> {
+) -> Result<[G; OUT_356], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    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 __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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_5]; 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_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_354] = { let __args: [G; IN_354] = []; 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 __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_8: G = __r_arr[0];
-        let __ret: [G; OUT_353] = [__v_7, __v_8];
-        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_356] = [__v_7, __v_8];
+        record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_1, __v_4]; 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 __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_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));
+            let __ret: [G; OUT_356] = [__v_9, __v_10];
+            record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+            let __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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_1, __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_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));
+                let __ret: [G; OUT_356] = [__v_11, __v_12];
+                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                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 __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_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_11]; 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];
                 match __v_12.as_canonical_u64() {
                   1u64 => {
                     let __v_13: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = []; 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_14: G = __r_arr[0];
-                    let __ret: [G; OUT_353] = [__v_13, __v_14];
-                    record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_356] = [__v_13, __v_14];
+                    record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    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 __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_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_13]; 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_14: G = __r_arr[0];
-                    let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+                    let __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_15: G = __r_arr[0];
-                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
                     let __v_16: G = __r_arr[0];
                     let __v_17: G = (__v_14 + __v_16);
                     match __v_17.as_canonical_u64() {
@@ -32950,12 +32393,12 @@ fn aiur_fn_353(
                         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_353] = [__v_18, __v_22];
-                        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_356] = [__v_18, __v_22];
+                        record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; 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_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 };
@@ -32966,31 +32409,31 @@ fn aiur_fn_353(
                             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_353] = [__v_21, __v_25];
-                            record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_356] = [__v_21, __v_25];
+                            record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
                             let __v_21: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                             let __v_22: G = __r_arr[0];
-                            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_22, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_22, __v_2, __v_3, __v_4]; 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_23: G = __r_arr[0];
                             match __v_14.as_canonical_u64() {
                               1u64 => {
-                                let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_23, __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 __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_23, __v_4]; 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_353] = [__v_24, __v_25];
-                                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_356] = [__v_24, __v_25];
+                                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_23]; 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 __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_23]; 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_24: G = __r_arr[0];
                                 let __v_25: G = __r_arr[1];
-                                let __ret: [G; OUT_353] = [__v_24, __v_25];
-                                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_356] = [__v_24, __v_25];
+                                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -33027,15 +32470,15 @@ fn aiur_fn_353(
   })
 }
 
-const INPUT_SIZE_354: usize = 0;
-const IN_354: usize = 0;
-const OUT_354: usize = 1;
-fn aiur_fn_354(
-  inp: [G; IN_354],
+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_354], ExecError> {
+) -> 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(64);
@@ -33054,21 +32497,21 @@ fn aiur_fn_354(
     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_354] = [__v_16];
-    record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_357] = [__v_16];
+    record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_355: usize = 0;
-const IN_355: usize = 0;
-const OUT_355: usize = 1;
-fn aiur_fn_355(
-  inp: [G; IN_355],
+const INPUT_SIZE_358: usize = 0;
+const IN_358: usize = 0;
+const OUT_358: usize = 1;
+fn aiur_fn_358(
+  inp: [G; IN_358],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_355], ExecError> {
+) -> Result<[G; OUT_358], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(0);
     let __v_1: G = G::from_u64(1);
@@ -33087,25 +32530,25 @@ fn aiur_fn_355(
     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_355] = [__v_16];
-    record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_358] = [__v_16];
+    record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_356: usize = 2;
-const IN_356: usize = 2;
-const OUT_356: usize = 2;
-fn aiur_fn_356(
-  inp: [G; IN_356],
+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_356], ExecError> {
+) -> Result<[G; OUT_359], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_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 };
@@ -33116,15 +32559,15 @@ fn aiur_fn_356(
         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_356] = [__v_5, __v_9];
-        record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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(2);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __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 };
@@ -33134,19 +32577,19 @@ fn aiur_fn_356(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+            let __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_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_13, __v_14]; 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_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_354] = { let __args: [G; IN_354] = []; 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 __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_17: G = __r_arr[0];
-                let __ret: [G; OUT_356] = [__v_16, __v_17];
-                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_359] = [__v_16, __v_17];
+                record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -33155,8 +32598,8 @@ fn aiur_fn_356(
                 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_356] = [__v_16, __v_20];
-                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_359] = [__v_16, __v_20];
+                record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -33170,8 +32613,8 @@ fn aiur_fn_356(
             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_356] = [__v_13, __v_17];
-            record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_359] = [__v_13, __v_17];
+            record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33183,19 +32626,19 @@ fn aiur_fn_356(
   })
 }
 
-const INPUT_SIZE_357: usize = 2;
-const IN_357: usize = 2;
-const OUT_357: usize = 2;
-fn aiur_fn_357(
-  inp: [G; IN_357],
+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_357], ExecError> {
+) -> Result<[G; OUT_360], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_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 };
@@ -33206,15 +32649,15 @@ fn aiur_fn_357(
         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_357] = [__v_5, __v_9];
-        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_360] = [__v_5, __v_9];
+        record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __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 };
@@ -33224,15 +32667,15 @@ fn aiur_fn_357(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
+            let __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_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_13, __v_14]; 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_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
+            let __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_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_13, __v_16]; 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_17: G = __r_arr[0];
             let __v_18: G = (__v_15 + __v_17);
             match __v_18.as_canonical_u64() {
@@ -33242,16 +32685,16 @@ fn aiur_fn_357(
                 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_357] = [__v_19, __v_23];
-                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_360] = [__v_19, __v_23];
+                record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_19: G = G::from_u64(1);
-                let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = []; 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_20: G = __r_arr[0];
-                let __ret: [G; OUT_357] = [__v_19, __v_20];
-                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_360] = [__v_19, __v_20];
+                record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -33262,8 +32705,8 @@ fn aiur_fn_357(
             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_357] = [__v_13, __v_17];
-            record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_360] = [__v_13, __v_17];
+            record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33275,15 +32718,15 @@ fn aiur_fn_357(
   })
 }
 
-const INPUT_SIZE_358: usize = 2;
-const IN_358: usize = 2;
-const OUT_358: usize = 2;
-fn aiur_fn_358(
-  inp: [G; IN_358],
+const INPUT_SIZE_361: usize = 2;
+const IN_361: usize = 2;
+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_358], ExecError> {
+) -> Result<[G; OUT_361], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33294,15 +32737,15 @@ fn aiur_fn_358(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+        let __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = []; 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_126] = { let __args: [G; IN_126] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = (__v_8 + __v_10);
         match __v_11.as_canonical_u64() {
@@ -33312,14 +32755,14 @@ fn aiur_fn_358(
             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_358] = [__v_12, __v_16];
-            record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_361] = [__v_12, __v_16];
+            record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(1);
-            let __ret: [G; OUT_358] = [__v_12, __v_0];
-            record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_361] = [__v_12, __v_0];
+            record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33330,23 +32773,23 @@ fn aiur_fn_358(
         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_358] = [__v_6, __v_10];
-        record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_361] = [__v_6, __v_10];
+        record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_359: usize = 1;
-const IN_359: usize = 1;
-const OUT_359: usize = 2;
-fn aiur_fn_359(
-  inp: [G; IN_359],
+const INPUT_SIZE_362: usize = 1;
+const IN_362: usize = 1;
+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_359], ExecError> {
+) -> Result<[G; OUT_362], 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 };
@@ -33359,8 +32802,8 @@ fn aiur_fn_359(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_359] = [__v_5, __v_0];
-            record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_362] = [__v_5, __v_0];
+            record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -33369,8 +32812,8 @@ fn aiur_fn_359(
             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));
+            let __ret: [G; OUT_362] = [__v_5, __v_9];
+            record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33381,23 +32824,23 @@ fn aiur_fn_359(
         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));
+        let __ret: [G; OUT_362] = [__v_5, __v_9];
+        record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_360: usize = 7;
-const IN_360: usize = 7;
-const OUT_360: usize = 2;
-fn aiur_fn_360(
-  inp: [G; IN_360],
+const INPUT_SIZE_363: usize = 7;
+const IN_363: usize = 7;
+const OUT_363: usize = 2;
+fn aiur_fn_363(
+  inp: [G; IN_363],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_360], ExecError> {
+) -> Result<[G; OUT_363], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33406,39 +32849,39 @@ fn aiur_fn_360(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    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 __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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } };
+    let __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_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+    let __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_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_11]; 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_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 __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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_13]; 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_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } };
+    let __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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
-    let __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 __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_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
     let __v_19: G = (__v_16 + __v_18);
     let __v_20: G = (__v_14 + __v_19);
     match __v_20.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
-        let __ret: [G; OUT_360] = [__v_21, __v_22];
-        record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_363] = [__v_21, __v_22];
+        record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -33451,12 +32894,12 @@ fn aiur_fn_360(
             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_360] = [__v_23, __v_27];
-            record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_363] = [__v_23, __v_27];
+            record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
             let __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 };
@@ -33467,16 +32910,16 @@ fn aiur_fn_360(
                 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_360] = [__v_26, __v_30];
-                record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_363] = [__v_26, __v_30];
+                record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__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[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 __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__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[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_26: G = __r_arr[0];
                 let __v_27: G = __r_arr[1];
-                let __ret: [G; OUT_360] = [__v_26, __v_27];
-                record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_363] = [__v_26, __v_27];
+                record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -33490,15 +32933,15 @@ fn aiur_fn_360(
   })
 }
 
-const INPUT_SIZE_361: usize = 2;
-const IN_361: usize = 2;
-const OUT_361: usize = 3;
-fn aiur_fn_361(
-  inp: [G; IN_361],
+const INPUT_SIZE_364: usize = 2;
+const IN_364: usize = 2;
+const OUT_364: usize = 3;
+fn aiur_fn_364(
+  inp: [G; IN_364],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_361], ExecError> {
+) -> Result<[G; OUT_364], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33516,15 +32959,15 @@ fn aiur_fn_361(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_10, __v_11]; 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_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 __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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_10, __v_13]; 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_14: G = __r_arr[0];
             let __v_15: G = (__v_12 + __v_14);
             match __v_15.as_canonical_u64() {
@@ -33534,8 +32977,8 @@ fn aiur_fn_361(
                 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_361] = [__v_16, __v_17, __v_20];
-                record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_364] = [__v_16, __v_17, __v_20];
+                record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -33549,8 +32992,8 @@ fn aiur_fn_361(
                     match __v_17.as_canonical_u64() {
                       0u64 => {
                         let __v_20: G = G::from_u64(1);
-                        let __ret: [G; OUT_361] = [__v_20, __v_14, __v_18];
-                        record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_364] = [__v_20, __v_14, __v_18];
+                        record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -33559,8 +33002,8 @@ fn aiur_fn_361(
                         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_361] = [__v_20, __v_21, __v_24];
-                        record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_364] = [__v_20, __v_21, __v_24];
+                        record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -33571,8 +33014,8 @@ fn aiur_fn_361(
                     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_361] = [__v_20, __v_21, __v_24];
-                    record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_364] = [__v_20, __v_21, __v_24];
+                    record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -33585,8 +33028,8 @@ fn aiur_fn_361(
             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_361] = [__v_10, __v_11, __v_14];
-            record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_364] = [__v_10, __v_11, __v_14];
+            record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33597,35 +33040,35 @@ fn aiur_fn_361(
         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_361] = [__v_6, __v_7, __v_10];
-        record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_364] = [__v_6, __v_7, __v_10];
+        record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_362: usize = 3;
-const IN_362: usize = 3;
-const OUT_362: usize = 2;
-fn aiur_fn_362(
-  inp: [G; IN_362],
+const INPUT_SIZE_365: usize = 3;
+const IN_365: usize = 3;
+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_362], ExecError> {
+) -> Result<[G; OUT_365], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
   0u64 => {
-    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 __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     break '__mc_0 [__v_3];
   },
   _ => {
-    let __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 __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_3: G = __r_arr[0];
     break '__mc_0 [__v_3];
   },
@@ -33633,7 +33076,7 @@ fn aiur_fn_362(
  };
     let __v_3: G = __mc_out___mc_0[0];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_2, __v_4]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3, __v_2, __v_4]; 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     match __v_5.as_canonical_u64() {
@@ -33646,12 +33089,12 @@ fn aiur_fn_362(
         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_340] = { let __args: [G; IN_340] = [__v_1]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1]; 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_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_362] = [__v_13, __v_17];
-        record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_365] = [__v_13, __v_17];
+        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -33660,8 +33103,8 @@ fn aiur_fn_362(
         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_362] = [__v_7, __v_11];
-        record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_365] = [__v_7, __v_11];
+        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -33671,15 +33114,15 @@ fn aiur_fn_362(
   })
 }
 
-const INPUT_SIZE_363: usize = 6;
-const IN_363: usize = 6;
-const OUT_363: usize = 2;
-fn aiur_fn_363(
-  inp: [G; IN_363],
+const INPUT_SIZE_366: usize = 6;
+const IN_366: usize = 6;
+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_363], ExecError> {
+) -> Result<[G; OUT_366], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33687,7 +33130,7 @@ fn aiur_fn_363(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2]; 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_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 };
@@ -33698,24 +33141,24 @@ fn aiur_fn_363(
         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_363] = [__v_9, __v_13];
-        record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_366] = [__v_9, __v_13];
+        record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_10, __v_5]; 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 __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_10, __v_5]; 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_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_361] = { let __args: [G; IN_361] = [__v_12, __v_5]; 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 __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_12, __v_5]; 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];
             let __v_18: G = __r_arr[2];
@@ -33726,26 +33169,26 @@ fn aiur_fn_363(
                 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_363] = [__v_19, __v_23];
-                record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_366] = [__v_19, __v_23];
+                record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__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[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 __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__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[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_19: G = __r_arr[0];
                 let __v_20: G = __r_arr[1];
-                let __ret: [G; OUT_363] = [__v_19, __v_20];
-                record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_366] = [__v_19, __v_20];
+                record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__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[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 __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__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[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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
-            let __ret: [G; OUT_363] = [__v_16, __v_17];
-            record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_366] = [__v_16, __v_17];
+            record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33757,15 +33200,15 @@ fn aiur_fn_363(
   })
 }
 
-const INPUT_SIZE_364: usize = 8;
-const IN_364: usize = 8;
-const OUT_364: usize = 2;
-fn aiur_fn_364(
-  inp: [G; IN_364],
+const INPUT_SIZE_367: usize = 8;
+const IN_367: usize = 8;
+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_364], ExecError> {
+) -> Result<[G; OUT_367], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33775,28 +33218,28 @@ fn aiur_fn_364(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_3, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_3, __v_5, __v_6, __v_7]; 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_5, __v_6, __v_7]; 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_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_8, __v_7]; 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 __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_8, __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_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_361] = { let __args: [G; IN_361] = [__v_9, __v_7]; 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 __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __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_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_362] = { let __args: [G; IN_362] = [__v_11, __v_12, __v_7]; 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 __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_11, __v_12, __v_7]; 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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
             match __v_16.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_14, __v_15, __v_7]; 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 __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_14, __v_15, __v_7]; 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_18: G = __r_arr[0];
                 let __v_19: G = __r_arr[1];
                 match __v_18.as_canonical_u64() {
@@ -33811,13 +33254,13 @@ fn aiur_fn_364(
                     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_785] = { let __args: [G; IN_785] = [__v_2, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_2, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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_404] = { let __args: [G; IN_404] = [__v_28, __v_30]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_28, __v_30]; 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_32: G = __r_arr[0];
-                    let __ret: [G; OUT_364] = [__v_31, __v_32];
-                    record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_367] = [__v_31, __v_32];
+                    record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -33826,8 +33269,8 @@ fn aiur_fn_364(
                     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_364] = [__v_20, __v_24];
-                    record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_367] = [__v_20, __v_24];
+                    record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -33838,8 +33281,8 @@ fn aiur_fn_364(
                 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_364] = [__v_18, __v_22];
-                record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_367] = [__v_18, __v_22];
+                record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -33850,8 +33293,8 @@ fn aiur_fn_364(
             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_364] = [__v_16, __v_20];
-            record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_367] = [__v_16, __v_20];
+            record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33862,23 +33305,23 @@ fn aiur_fn_364(
         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_364] = [__v_13, __v_17];
-        record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_367] = [__v_13, __v_17];
+        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_365: usize = 9;
-const IN_365: usize = 9;
-const OUT_365: usize = 2;
-fn aiur_fn_365(
-  inp: [G; IN_365],
+const INPUT_SIZE_368: usize = 9;
+const IN_368: usize = 9;
+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_365], ExecError> {
+) -> Result<[G; OUT_368], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33892,14 +33335,14 @@ fn aiur_fn_365(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_10, __v_6, __v_7, __v_8]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_10, __v_6, __v_7, __v_8]; 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_8]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_13, __v_8]; 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
@@ -33909,14 +33352,14 @@ fn aiur_fn_365(
             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_365] = [__v_16, __v_20];
-            record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_368] = [__v_16, __v_20];
+            record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_15]; 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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_15]; 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_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_16]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_16]; 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_17: G = __r_arr[0];
             let __v_18: G = G::from_u64(2);
             let __v_19: G = G::from_u64(0);
@@ -33925,10 +33368,10 @@ fn aiur_fn_365(
             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_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 __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_25: G = __r_arr[0];
             let __v_26: G = G::from_u64(0);
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_25, __v_8, __v_26]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_25, __v_8, __v_26]; 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_27: G = __r_arr[0];
             let __v_28: G = __r_arr[1];
             match __v_27.as_canonical_u64() {
@@ -33938,8 +33381,8 @@ fn aiur_fn_365(
                 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_365] = [__v_29, __v_33];
-                record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_368] = [__v_29, __v_33];
+                record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
@@ -33956,13 +33399,13 @@ fn aiur_fn_365(
                 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_785] = { let __args: [G; IN_785] = [__v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__args, record, io_buffer, __cu)? } };
                 let __v_42: G = __r_arr[0];
-                let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_40, __v_42]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_40, __v_42]; 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_43: G = __r_arr[0];
                 let __v_44: G = G::from_u64(1);
-                let __ret: [G; OUT_365] = [__v_44, __v_43];
-                record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_368] = [__v_44, __v_43];
+                record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -33976,11 +33419,11 @@ fn aiur_fn_365(
         }
       },
       0u64 => {
-        let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__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[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 __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__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[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_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
-        let __ret: [G; OUT_365] = [__v_9, __v_10];
-        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_368] = [__v_9, __v_10];
+        record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -33990,15 +33433,15 @@ fn aiur_fn_365(
   })
 }
 
-const INPUT_SIZE_366: usize = 8;
-const IN_366: usize = 8;
-const OUT_366: usize = 2;
-fn aiur_fn_366(
-  inp: [G; IN_366],
+const INPUT_SIZE_369: usize = 8;
+const IN_369: usize = 8;
+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_366], ExecError> {
+) -> Result<[G; OUT_369], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -34009,19 +33452,19 @@ fn aiur_fn_366(
     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_767] = { let __args: [G; IN_767] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = G::from_u64(1);
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_9, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_9, __v_5, __v_6, __v_7]; 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_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_11, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_11, __v_5, __v_6, __v_7]; 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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_12, __v_7]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_12, __v_7]; 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_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
-    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_7]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_13, __v_7]; 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_16: G = __r_arr[0];
     let __v_17: G = __r_arr[1];
     match __v_14.as_canonical_u64() {
@@ -34031,8 +33474,8 @@ fn aiur_fn_366(
         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));
+        let __ret: [G; OUT_369] = [__v_18, __v_22];
+        record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -34043,19 +33486,19 @@ fn aiur_fn_366(
             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));
+            let __ret: [G; OUT_369] = [__v_18, __v_22];
+            record.function_queries[369].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_312] = { let __args: [G; IN_312] = [__v_15, __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 __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_15, __v_17]; 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_18: G = __r_arr[0];
     break '__mc_0 [__v_18];
   },
   0u64 => {
-    let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_15, __v_17]; 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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_15, __v_17]; 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_18: G = __r_arr[0];
     break '__mc_0 [__v_18];
   },
@@ -34065,11 +33508,11 @@ fn aiur_fn_366(
 }
  };
             let __v_18: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__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[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 __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__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[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_19: G = __r_arr[0];
             let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_366] = [__v_19, __v_20];
-            record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_369] = [__v_19, __v_20];
+            record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -34084,15 +33527,15 @@ fn aiur_fn_366(
   })
 }
 
-const INPUT_SIZE_367: usize = 11;
-const IN_367: usize = 11;
-const OUT_367: usize = 2;
-fn aiur_fn_367(
-  inp: [G; IN_367],
+const INPUT_SIZE_370: usize = 11;
+const IN_370: usize = 11;
+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_367], ExecError> {
+) -> Result<[G; OUT_370], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -34105,10 +33548,10 @@ fn aiur_fn_367(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    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 __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_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_10, __v_12]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_10, __v_12]; 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
     match __v_13.as_canonical_u64() {
@@ -34118,15 +33561,15 @@ fn aiur_fn_367(
         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_367] = [__v_15, __v_19];
-        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_370] = [__v_15, __v_19];
+        record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        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 __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_15: G = __r_arr[0];
         let __v_16: G = G::from_u64(0);
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_15, __v_10, __v_16]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_15, __v_10, __v_16]; 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_17: G = __r_arr[0];
         let __v_18: G = __r_arr[1];
         match __v_17.as_canonical_u64() {
@@ -34136,26 +33579,26 @@ fn aiur_fn_367(
             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_367] = [__v_19, __v_23];
-            record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_370] = [__v_19, __v_23];
+            record.function_queries[370].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_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 __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_335] = { let __args: [G; IN_335] = [__v_19, __v_10, __v_20]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_19, __v_10, __v_20]; 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_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_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 __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = []; 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_19: G = __r_arr[0];
     let __v_20: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_19, __v_10, __v_20]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_19, __v_10, __v_20]; 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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     break '__mc_0 [__v_21, __v_22];
@@ -34174,8 +33617,8 @@ fn aiur_fn_367(
                 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_367] = [__v_21, __v_25];
-                record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_370] = [__v_21, __v_25];
+                record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
@@ -34215,12 +33658,12 @@ fn aiur_fn_367(
   1u64 => {
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+        let __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];
       },
       0u64 => {
-        let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } };
+        let __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];
       },
@@ -34232,12 +33675,12 @@ fn aiur_fn_367(
   0u64 => {
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+        let __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];
       },
       0u64 => {
-        let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__args, record, io_buffer, __cu)? } };
+        let __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_53: G = __r_arr[0];
         break '__mc_1 [__v_53];
       },
@@ -34253,7 +33696,7 @@ fn aiur_fn_367(
  };
                 let __v_53: G = __mc_out___mc_1[0];
                 let __v_54: G = G::from_u64(0);
-                let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_53, __v_10, __v_54]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_53, __v_10, __v_54]; 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_55: G = __r_arr[0];
                 let __v_56: G = __r_arr[1];
                 match __v_55.as_canonical_u64() {
@@ -34263,8 +33706,8 @@ fn aiur_fn_367(
                     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_367] = [__v_57, __v_61];
-                    record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_370] = [__v_57, __v_61];
+                    record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
@@ -34278,8 +33721,8 @@ fn aiur_fn_367(
                         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_367] = [__v_60, __v_64];
-                        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_370] = [__v_60, __v_64];
+                        record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
@@ -34298,11 +33741,11 @@ fn aiur_fn_367(
                         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_368] = { let __args: [G; IN_368] = [__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[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 __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__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[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_75: G = __r_arr[0];
                         let __v_76: G = __r_arr[1];
-                        let __ret: [G; OUT_367] = [__v_75, __v_76];
-                        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_370] = [__v_75, __v_76];
+                        record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -34332,15 +33775,15 @@ fn aiur_fn_367(
   })
 }
 
-const INPUT_SIZE_368: usize = 8;
-const IN_368: usize = 8;
-const OUT_368: usize = 2;
-fn aiur_fn_368(
-  inp: [G; IN_368],
+const INPUT_SIZE_371: usize = 8;
+const IN_371: usize = 8;
+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_368], ExecError> {
+) -> Result<[G; OUT_371], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -34352,12 +33795,12 @@ fn aiur_fn_368(
     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_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 __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];
   },
   0u64 => {
-    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 __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_8: G = __r_arr[0];
     break '__mc_0 [__v_8];
   },
@@ -34368,7 +33811,7 @@ fn aiur_fn_368(
  };
     let __v_8: G = __mc_out___mc_0[0];
     let __v_9: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_8, __v_7, __v_9]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_8, __v_7, __v_9]; 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     match __v_10.as_canonical_u64() {
@@ -34378,8 +33821,8 @@ fn aiur_fn_368(
         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_368] = [__v_12, __v_16];
-        record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_371] = [__v_12, __v_16];
+        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -34387,18 +33830,18 @@ fn aiur_fn_368(
         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_781] = { let __args: [G; IN_781] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[784].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_784] = unsafe { *(result.output.as_ptr() as *const [G; OUT_784]) }; __ret } else { aiur_fn_784(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_14, __v_16]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_14, __v_16]; 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_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_17, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_17, __v_5, __v_6, __v_7]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_18, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_18, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_19]; 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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
         let __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 };
@@ -34409,13 +33852,13 @@ fn aiur_fn_368(
             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_368] = [__v_25, __v_29];
-            record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_371] = [__v_25, __v_29];
+            record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_25: G = G::from_u64(0);
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_26: G = __r_arr[0];
             let __v_27: G = G::from_u64(2);
             let __v_28: G = G::from_u64(1);
@@ -34430,13 +33873,13 @@ fn aiur_fn_368(
             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_785] = { let __args: [G; IN_785] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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_404] = { let __args: [G; IN_404] = [__v_38, __v_40]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_38, __v_40]; 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_42: G = __r_arr[0];
-            let __ret: [G; OUT_368] = [__v_41, __v_42];
-            record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_371] = [__v_41, __v_42];
+            record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -34451,20 +33894,20 @@ fn aiur_fn_368(
   })
 }
 
-const INPUT_SIZE_369: usize = 3;
-const IN_369: usize = 3;
-const OUT_369: usize = 2;
-fn aiur_fn_369(
-  inp: [G; IN_369],
+const INPUT_SIZE_372: usize = 3;
+const IN_372: usize = 3;
+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_369], ExecError> {
+) -> Result<[G; OUT_372], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !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_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 };
@@ -34475,13 +33918,13 @@ fn aiur_fn_369(
         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_369] = [__v_6, __v_10];
-        record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_372] = [__v_6, __v_10];
+        record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __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];
@@ -34492,13 +33935,13 @@ fn aiur_fn_369(
           7u64 => {
             match __v_9.as_canonical_u64() {
               1u64 => {
-                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 __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_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_12]; 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_13: G = __r_arr[0];
                 match __v_13.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } else { aiur_fn_761(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
                     let __v_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
                     let __v_16: G = __r_arr[2];
@@ -34517,32 +33960,32 @@ fn aiur_fn_369(
                     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_369] = [__v_27, __v_31];
-                    record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_372] = [__v_27, __v_31];
+                    record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+                    let __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_14: G = __r_arr[0];
-                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_14]; 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_15: G = __r_arr[0];
                     match __v_15.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_10, __v_2]; 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 __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_16: G = __r_arr[0];
                         let __v_17: G = __r_arr[1];
-                        let __ret: [G; OUT_369] = [__v_16, __v_17];
-                        record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_372] = [__v_16, __v_17];
+                        record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        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 __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_16: G = __r_arr[0];
-                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_16]; 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_17: G = __r_arr[0];
-                        let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+                        let __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_18: G = __r_arr[0];
-                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_18]; 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_19: G = __r_arr[0];
                         let __v_20: G = (__v_17 + __v_19);
                         match __v_20.as_canonical_u64() {
@@ -34552,16 +33995,16 @@ fn aiur_fn_369(
                             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));
+                            let __ret: [G; OUT_372] = [__v_21, __v_25];
+                            record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_10, __v_2]; 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 __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
                             let __v_21: G = __r_arr[0];
                             let __v_22: G = __r_arr[1];
-                            let __ret: [G; OUT_369] = [__v_21, __v_22];
-                            record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_372] = [__v_21, __v_22];
+                            record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -34582,8 +34025,8 @@ fn aiur_fn_369(
                 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_369] = [__v_12, __v_16];
-                record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_372] = [__v_12, __v_16];
+                record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -34594,8 +34037,8 @@ fn aiur_fn_369(
             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_369] = [__v_12, __v_16];
-            record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_372] = [__v_12, __v_16];
+            record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -34607,15 +34050,15 @@ fn aiur_fn_369(
   })
 }
 
-const INPUT_SIZE_370: usize = 2;
-const IN_370: usize = 2;
-const OUT_370: usize = 2;
-fn aiur_fn_370(
-  inp: [G; IN_370],
+const INPUT_SIZE_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_370], ExecError> {
+) -> Result<[G; OUT_373], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -34625,10 +34068,10 @@ fn aiur_fn_370(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        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 __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_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1, __v_6]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_5, __v_1, __v_6]; 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
         match __v_7.as_canonical_u64() {
@@ -34640,8 +34083,8 @@ fn aiur_fn_370(
             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_370] = [__v_9, __v_15];
-            record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_373] = [__v_9, __v_15];
+            record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -34650,8 +34093,8 @@ fn aiur_fn_370(
             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_370] = [__v_9, __v_13];
-            record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_373] = [__v_9, __v_13];
+            record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -34665,30 +34108,30 @@ fn aiur_fn_370(
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_370] = [__v_5, __v_9];
-        record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_373] = [__v_5, __v_9];
+        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_371: usize = 2;
-const IN_371: usize = 2;
-const OUT_371: usize = 2;
-fn aiur_fn_371(
-  inp: [G; IN_371],
+const INPUT_SIZE_374: usize = 2;
+const IN_374: usize = 2;
+const OUT_374: usize = 2;
+fn aiur_fn_374(
+  inp: [G; IN_374],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_371], ExecError> {
+) -> Result<[G; OUT_374], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    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 __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_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_2, __v_1, __v_3]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2, __v_1, __v_3]; 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -34698,14 +34141,14 @@ fn aiur_fn_371(
         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));
+        let __ret: [G; OUT_374] = [__v_6, __v_10];
+        record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_6]; 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 __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_6]; 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_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(7);
         let __v_9: G = G::from_u64(0);
@@ -34721,8 +34164,8 @@ fn aiur_fn_371(
         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_371] = [__v_18, __v_21];
-        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_374] = [__v_18, __v_21];
+        record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -34732,51 +34175,51 @@ fn aiur_fn_371(
   })
 }
 
-const INPUT_SIZE_372: usize = 1;
-const IN_372: usize = 1;
-const OUT_372: usize = 4;
-fn aiur_fn_372(
-  inp: [G; IN_372],
+const INPUT_SIZE_375: usize = 1;
+const IN_375: usize = 1;
+const OUT_375: usize = 4;
+fn aiur_fn_375(
+  inp: [G; IN_375],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_372], ExecError> {
+) -> Result<[G; OUT_375], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
     let __v_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_314] = { let __args: [G; IN_314] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
     let __v_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_314] = { let __args: [G; IN_314] = [__v_6, __v_7]; 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 __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
     let __v_10: G = G::from_u64(0);
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_9, __v_10]; 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 __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __ret: [G; OUT_372] = [__v_2, __v_5, __v_8, __v_11];
-    record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_375] = [__v_2, __v_5, __v_8, __v_11];
+    record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_373: usize = 1;
-const IN_373: usize = 1;
-const OUT_373: usize = 1;
-fn aiur_fn_373(
-  inp: [G; IN_373],
+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_373], ExecError> {
+) -> Result<[G; OUT_376], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -34810,41 +34253,41 @@ fn aiur_fn_373(
     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_373] = [__v_30];
-    record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_376] = [__v_30];
+    record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_374: usize = 1;
-const IN_374: usize = 1;
-const OUT_374: usize = 1;
-fn aiur_fn_374(
-  inp: [G; IN_374],
+const INPUT_SIZE_377: usize = 1;
+const IN_377: usize = 1;
+const OUT_377: usize = 1;
+fn aiur_fn_377(
+  inp: [G; IN_377],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_374], ExecError> {
+) -> Result<[G; OUT_377], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(65);
-    let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
-    let __ret: [G; OUT_374] = [__v_2];
-    record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_377] = [__v_2];
+    record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_375: usize = 2;
-const IN_375: usize = 2;
-const OUT_375: usize = 1;
-fn aiur_fn_375(
-  inp: [G; IN_375],
+const INPUT_SIZE_378: usize = 2;
+const IN_378: usize = 2;
+const OUT_378: usize = 1;
+fn aiur_fn_378(
+  inp: [G; IN_378],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_375], ExecError> {
+) -> Result<[G; OUT_378], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -34854,18 +34297,18 @@ fn aiur_fn_375(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_375] = [__v_1];
-        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_378] = [__v_1];
+        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_3, __v_4]; 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 __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_3, __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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_6, __v_5]; 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 __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_6, __v_5]; 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 __ret: [G; OUT_375] = [__v_7];
-        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_378] = [__v_7];
+        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -34875,15 +34318,15 @@ fn aiur_fn_375(
   })
 }
 
-const INPUT_SIZE_376: usize = 2;
-const IN_376: usize = 2;
-const OUT_376: usize = 2;
-fn aiur_fn_376(
-  inp: [G; IN_376],
+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_376], ExecError> {
+) -> Result<[G; OUT_379], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -34891,8 +34334,8 @@ fn aiur_fn_376(
     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_376] = [__v_0, __v_1];
-        record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_379] = [__v_0, __v_1];
+        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -34913,8 +34356,8 @@ fn aiur_fn_376(
                 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_376] = [__v_15, __v_8];
-                record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_379] = [__v_15, __v_8];
+                record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -34951,8 +34394,8 @@ fn aiur_fn_376(
                         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_376] = [__v_25, __v_13];
-                        record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_379] = [__v_25, __v_13];
+                        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -35001,8 +34444,8 @@ fn aiur_fn_376(
                             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_376] = [__v_33, __v_16];
-                            record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_379] = [__v_33, __v_16];
+                            record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -35037,22 +34480,22 @@ fn aiur_fn_376(
   })
 }
 
-const INPUT_SIZE_377: usize = 2;
-const IN_377: usize = 2;
-const OUT_377: usize = 2;
-fn aiur_fn_377(
-  inp: [G; IN_377],
+const INPUT_SIZE_380: usize = 2;
+const IN_380: usize = 2;
+const OUT_380: usize = 2;
+fn aiur_fn_380(
+  inp: [G; IN_380],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_377], ExecError> {
+) -> Result<[G; OUT_380], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    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 __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_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_2, __v_1, __v_3]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2, __v_1, __v_3]; 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -35062,15 +34505,15 @@ fn aiur_fn_377(
         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_377] = [__v_6, __v_10];
-        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_380] = [__v_6, __v_10];
+        record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
+        let __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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_1, __v_7]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6, __v_1, __v_7]; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
@@ -35080,15 +34523,15 @@ fn aiur_fn_377(
             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_377] = [__v_10, __v_14];
-            record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_380] = [__v_10, __v_14];
+            record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
+            let __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_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_10, __v_1, __v_11]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_10, __v_1, __v_11]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             match __v_12.as_canonical_u64() {
@@ -35098,15 +34541,15 @@ fn aiur_fn_377(
                 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_377] = [__v_14, __v_18];
-                record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_380] = [__v_14, __v_18];
+                record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                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 __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_14: G = __r_arr[0];
                 let __v_15: G = G::from_u64(0);
-                let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_14, __v_1, __v_15]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_14, __v_1, __v_15]; 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_16: G = __r_arr[0];
                 let __v_17: G = __r_arr[1];
                 match __v_16.as_canonical_u64() {
@@ -35116,15 +34559,15 @@ fn aiur_fn_377(
                     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_377] = [__v_18, __v_22];
-                    record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_380] = [__v_18, __v_22];
+                    record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
+                    let __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_18: G = __r_arr[0];
                     let __v_19: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_18, __v_1, __v_19]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_18, __v_1, __v_19]; 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_20: G = __r_arr[0];
                     let __v_21: G = __r_arr[1];
                     match __v_20.as_canonical_u64() {
@@ -35134,8 +34577,8 @@ fn aiur_fn_377(
                         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_377] = [__v_22, __v_26];
-                        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_380] = [__v_22, __v_26];
+                        record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       1u64 => {
@@ -35177,14 +34620,14 @@ fn aiur_fn_377(
                         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_378] = { let __args: [G; IN_378] = [__v_0, __v_56, __v_59, __v_47]; 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 __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_0, __v_56, __v_59, __v_47]; 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_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_377] = [__v_61, __v_64];
-                        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_380] = [__v_61, __v_64];
+                        record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -35214,15 +34657,15 @@ fn aiur_fn_377(
   })
 }
 
-const INPUT_SIZE_378: usize = 4;
-const IN_378: usize = 4;
-const OUT_378: usize = 1;
-fn aiur_fn_378(
-  inp: [G; IN_378],
+const INPUT_SIZE_381: usize = 4;
+const IN_381: usize = 4;
+const OUT_381: usize = 1;
+fn aiur_fn_381(
+  inp: [G; IN_381],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_378], ExecError> {
+) -> Result<[G; OUT_381], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -35234,15 +34677,15 @@ fn aiur_fn_378(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_378] = [__v_1];
-        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_381] = [__v_1];
+        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_5, __v_6]; 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 __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_5, __v_6]; 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_7]; 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 __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_7]; 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_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(7);
         let __v_11: G = G::from_u64(0);
@@ -35254,13 +34697,13 @@ fn aiur_fn_378(
         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_378] = { let __args: [G; IN_378] = [__v_8, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_8, __v_1, __v_2, __v_3]; 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_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_378] = [__v_23];
-        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_381] = [__v_23];
+        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35270,15 +34713,15 @@ fn aiur_fn_378(
   })
 }
 
-const INPUT_SIZE_379: usize = 2;
-const IN_379: usize = 2;
-const OUT_379: usize = 1;
-fn aiur_fn_379(
-  inp: [G; IN_379],
+const INPUT_SIZE_382: usize = 2;
+const IN_382: usize = 2;
+const OUT_382: usize = 1;
+fn aiur_fn_382(
+  inp: [G; IN_382],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_379], ExecError> {
+) -> Result<[G; OUT_382], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -35291,18 +34734,18 @@ fn aiur_fn_379(
       7u64 => {
         match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_4, __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 __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_4, __v_1]; 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_6: G = __r_arr[0];
             let __v_7: G = __r_arr[1];
             match __v_6.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_379] = [__v_7];
-                record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_382] = [__v_7];
+                record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __ret: [G; OUT_379] = [__v_0];
-                record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_382] = [__v_0];
+                record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -35311,35 +34754,35 @@ fn aiur_fn_379(
             }
           },
           _ => {
-            let __ret: [G; OUT_379] = [__v_0];
-            record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_382] = [__v_0];
+            record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_379] = [__v_0];
-        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_382] = [__v_0];
+        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_380: usize = 3;
-const IN_380: usize = 3;
-const OUT_380: usize = 2;
-fn aiur_fn_380(
-  inp: [G; IN_380],
+const INPUT_SIZE_383: usize = 3;
+const IN_383: usize = 3;
+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_380], ExecError> {
+) -> 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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __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];
@@ -35356,7 +34799,7 @@ fn aiur_fn_380(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_7, __v_15]; 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 __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_7, __v_15]; 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_16: G = __r_arr[0];
         let __v_17: G = __r_arr[1];
         let __v_18: G = __r_arr[2];
@@ -35364,7 +34807,7 @@ fn aiur_fn_380(
         let __v_20: G = __r_arr[4];
         match __v_16.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; 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_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() {
@@ -35374,22 +34817,22 @@ fn aiur_fn_380(
                 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_380] = [__v_23, __v_27];
-                record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_383] = [__v_23, __v_27];
+                record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_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_785] = { let __args: [G; IN_785] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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_404] = { let __args: [G; IN_404] = [__v_25, __v_26]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_25, __v_26]; 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_28: G = __r_arr[0];
-                let __ret: [G; OUT_380] = [__v_27, __v_28];
-                record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_383] = [__v_27, __v_28];
+                record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -35403,8 +34846,8 @@ fn aiur_fn_380(
             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_380] = [__v_21, __v_25];
-            record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_383] = [__v_21, __v_25];
+            record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -35415,34 +34858,34 @@ fn aiur_fn_380(
         let __v_17: G = G::from_u64(0);
         let __v_18: G = G::from_u64(0);
         let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_380] = [__v_15, __v_19];
-        record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_383] = [__v_15, __v_19];
+        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_381: usize = 5;
-const IN_381: usize = 5;
-const OUT_381: usize = 2;
-fn aiur_fn_381(
-  inp: [G; IN_381],
+const INPUT_SIZE_384: usize = 5;
+const IN_384: usize = 5;
+const OUT_384: usize = 2;
+fn aiur_fn_384(
+  inp: [G; IN_384],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_381], ExecError> {
+) -> Result<[G; OUT_384], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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_767] = { let __args: [G; IN_767] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } };
+    let __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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_5, __v_6]; 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_7: G = __r_arr[0];
     match __v_7.as_canonical_u64() {
       0u64 => {
@@ -35451,8 +34894,8 @@ fn aiur_fn_381(
         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_381] = [__v_8, __v_12];
-        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_384] = [__v_8, __v_12];
+        record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -35465,11 +34908,11 @@ fn aiur_fn_381(
             let __v_11: G = __loaded[3];
             match __v_8.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __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 __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_13: G = __r_arr[0];
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_12, __v_13]; 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_14: G = __r_arr[0];
                 match __v_14.as_canonical_u64() {
                   0u64 => {
@@ -35478,12 +34921,12 @@ fn aiur_fn_381(
                     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_381] = [__v_15, __v_19];
-                    record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_384] = [__v_15, __v_19];
+                    record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
                     let __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 };
@@ -35494,25 +34937,25 @@ fn aiur_fn_381(
                         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_381] = [__v_18, __v_22];
-                        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_384] = [__v_18, __v_22];
+                        record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
                         let __v_18: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                         let __v_19: G = __r_arr[0];
                         let __v_20: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                         let __v_21: G = __r_arr[0];
                         let __v_22: G = G::from_u64(2);
-                        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                         let __v_23: G = __r_arr[0];
                         let __v_24: G = G::from_u64(3);
-                        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                         let __v_25: G = __r_arr[0];
                         let __v_26: G = G::from_u64(4);
-                        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                         let __v_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];
@@ -35545,10 +34988,10 @@ fn aiur_fn_381(
                                     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_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 __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_50: G = __r_arr[0];
                                     let __v_51: G = G::from_u64(0);
-                                    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_50, __v_4, __v_51]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_50, __v_4, __v_51]; 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_52: G = __r_arr[0];
                                     let __v_53: G = __r_arr[1];
                                     match __v_52.as_canonical_u64() {
@@ -35581,13 +35024,13 @@ fn aiur_fn_381(
                                         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_785] = { let __args: [G; IN_785] = [__v_3, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_3, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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_404] = { let __args: [G; IN_404] = [__v_80, __v_82]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_80, __v_82]; 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_84: G = __r_arr[0];
-                                        let __ret: [G; OUT_381] = [__v_83, __v_84];
-                                        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_384] = [__v_83, __v_84];
+                                        record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       0u64 => {
@@ -35596,8 +35039,8 @@ fn aiur_fn_381(
                                         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_381] = [__v_54, __v_58];
-                                        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_384] = [__v_54, __v_58];
+                                        record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -35611,8 +35054,8 @@ fn aiur_fn_381(
                                     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_381] = [__v_45, __v_49];
-                                    record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_384] = [__v_45, __v_49];
+                                    record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -35623,8 +35066,8 @@ fn aiur_fn_381(
                                 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_381] = [__v_36, __v_40];
-                                record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_384] = [__v_36, __v_40];
+                                record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -35635,8 +35078,8 @@ fn aiur_fn_381(
                             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_381] = [__v_32, __v_36];
-                            record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_384] = [__v_32, __v_36];
+                            record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -35657,8 +35100,8 @@ fn aiur_fn_381(
                 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_381] = [__v_12, __v_16];
-                record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_384] = [__v_12, __v_16];
+                record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -35669,8 +35112,8 @@ fn aiur_fn_381(
             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_381] = [__v_8, __v_12];
-            record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_384] = [__v_8, __v_12];
+            record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -35682,15 +35125,15 @@ fn aiur_fn_381(
   })
 }
 
-const INPUT_SIZE_382: usize = 2;
-const IN_382: usize = 2;
-const OUT_382: usize = 5;
-fn aiur_fn_382(
-  inp: [G; IN_382],
+const INPUT_SIZE_385: usize = 2;
+const IN_385: usize = 2;
+const OUT_385: usize = 5;
+fn aiur_fn_385(
+  inp: [G; IN_385],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_382], ExecError> {
+) -> Result<[G; OUT_385], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -35703,14 +35146,14 @@ fn aiur_fn_382(
       4u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_1 + __v_6);
-        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_4, __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 = __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_382] = [__v_8, __v_9, __v_10, __v_11, __v_12];
-        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_385] = [__v_8, __v_9, __v_10, __v_11, __v_12];
+        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
@@ -35728,8 +35171,8 @@ fn aiur_fn_382(
                 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_382] = [__v_11, __v_1, __v_3, __v_4, __v_14];
-                record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_385] = [__v_11, __v_1, __v_3, __v_4, __v_14];
+                record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -35738,8 +35181,8 @@ fn aiur_fn_382(
                 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_382] = [__v_11, __v_12, __v_13, __v_14, __v_15];
-                record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_385] = [__v_11, __v_12, __v_13, __v_14, __v_15];
+                record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -35750,8 +35193,8 @@ fn aiur_fn_382(
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
-            let __ret: [G; OUT_382] = [__v_10, __v_11, __v_12, __v_13, __v_14];
-            record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_385] = [__v_10, __v_11, __v_12, __v_13, __v_14];
+            record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -35762,23 +35205,23 @@ fn aiur_fn_382(
         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_382] = [__v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_385] = [__v_6, __v_7, __v_8, __v_9, __v_10];
+        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_383: usize = 1;
-const IN_383: usize = 1;
-const OUT_383: usize = 1;
-fn aiur_fn_383(
-  inp: [G; IN_383],
+const INPUT_SIZE_386: usize = 1;
+const IN_386: usize = 1;
+const OUT_386: usize = 1;
+fn aiur_fn_386(
+  inp: [G; IN_386],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_383], ExecError> {
+) -> Result<[G; OUT_386], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -35790,77 +35233,77 @@ fn aiur_fn_383(
       0u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_2 + __v_5);
-        let __ret: [G; OUT_383] = [__v_6];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_386] = [__v_6];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_383] = [__v_5];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_386] = [__v_5];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_383] = [__v_5];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_386] = [__v_5];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_383] = [__v_5];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_386] = [__v_5];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_2]; 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 __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_3]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_5, __v_6]; 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 __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_5, __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 __ret: [G; OUT_383] = [__v_7];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_386] = [__v_7];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_2]; 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 __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_3]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_6]; 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 __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_6]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_5, __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 __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_5, __v_7]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_383] = [__v_8];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_386] = [__v_8];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_2]; 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 __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_3]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_6]; 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 __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_6]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_5, __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 __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_5, __v_7]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_383] = [__v_8];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_386] = [__v_8];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_2, __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 __ret: [G; OUT_383] = [__v_5];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_386] = [__v_5];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__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_383] = [__v_5];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_386] = [__v_5];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35870,59 +35313,59 @@ fn aiur_fn_383(
   })
 }
 
-const INPUT_SIZE_384: usize = 3;
-const IN_384: usize = 3;
-const OUT_384: usize = 1;
-fn aiur_fn_384(
-  inp: [G; IN_384],
+const INPUT_SIZE_387: usize = 3;
+const IN_387: usize = 3;
+const OUT_387: usize = 1;
+fn aiur_fn_387(
+  inp: [G; IN_387],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_384], ExecError> {
+) -> Result<[G; OUT_387], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0]; 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_1]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_1]; 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3, __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 __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_3, __v_4]; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_2]; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_6]; 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 __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_6]; 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_5, __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 __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_5, __v_7]; 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_8: G = __r_arr[0];
-    let __ret: [G; OUT_384] = [__v_8];
-    record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_387] = [__v_8];
+    record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_385: usize = 2;
-const IN_385: usize = 2;
-const OUT_385: usize = 1;
-fn aiur_fn_385(
-  inp: [G; IN_385],
+const INPUT_SIZE_388: usize = 2;
+const IN_388: usize = 2;
+const OUT_388: usize = 1;
+fn aiur_fn_388(
+  inp: [G; IN_388],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_385], ExecError> {
+) -> Result<[G; OUT_388], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = { 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_385] = [__v_1];
-        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_388] = [__v_1];
+        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_385] = [__v_0];
-        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_388] = [__v_0];
+        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35932,57 +35375,57 @@ fn aiur_fn_385(
   })
 }
 
-const INPUT_SIZE_386: usize = 1;
-const IN_386: usize = 1;
-const OUT_386: usize = 1;
-fn aiur_fn_386(
-  inp: [G; IN_386],
+const INPUT_SIZE_389: usize = 1;
+const IN_389: usize = 1;
+const OUT_389: usize = 1;
+fn aiur_fn_389(
+  inp: [G; IN_389],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_386], ExecError> {
+) -> Result<[G; OUT_389], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(0);
-        let __ret: [G; OUT_386] = [__v_1];
-        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_389] = [__v_1];
+        record.function_queries[389].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_386] = [__v_2];
-        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_389] = [__v_2];
+        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_387: usize = 2;
-const IN_387: usize = 2;
-const OUT_387: usize = 1;
-fn aiur_fn_387(
-  inp: [G; IN_387],
+const INPUT_SIZE_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_387], ExecError> {
+) -> Result<[G; OUT_390], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __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_0];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_390] = [__v_0];
+        record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_387] = [__v_1];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_390] = [__v_1];
+        record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35992,15 +35435,15 @@ fn aiur_fn_387(
   })
 }
 
-const INPUT_SIZE_388: usize = 3;
-const IN_388: usize = 3;
-const OUT_388: usize = 1;
-fn aiur_fn_388(
-  inp: [G; IN_388],
+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_388], ExecError> {
+) -> Result<[G; OUT_391], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36016,14 +35459,14 @@ fn aiur_fn_388(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_388] = [__v_8];
-            record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_391] = [__v_8];
+            record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-            let __ret: [G; OUT_388] = [__v_8];
-            record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_391] = [__v_8];
+            record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36033,37 +35476,37 @@ fn aiur_fn_388(
       },
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_7];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_7];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_7];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_4, __v_1, __v_2]; 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];
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_388] = [__v_8];
-            record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_391] = [__v_8];
+            record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_5, __v_1, __v_2]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_388] = [__v_8];
-            record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_391] = [__v_8];
+            record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36072,31 +35515,31 @@ fn aiur_fn_388(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_5, __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 __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_4, __v_5, __v_1, __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_7: G = __r_arr[0];
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_7];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_5, __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 __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_4, __v_5, __v_1, __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_7: G = __r_arr[0];
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_7];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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 __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_7];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6, __v_1, __v_2]; 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 __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_6, __v_1, __v_2]; 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_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_7];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36106,27 +35549,27 @@ fn aiur_fn_388(
   })
 }
 
-const INPUT_SIZE_389: usize = 4;
-const IN_389: usize = 4;
-const OUT_389: usize = 1;
-fn aiur_fn_389(
-  inp: [G; IN_389],
+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_389], ExecError> {
+) -> Result<[G; OUT_392], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_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];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_389] = [__v_5];
-        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_392] = [__v_5];
+        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -36134,10 +35577,10 @@ fn aiur_fn_389(
         let __v_6: G = (__v_2 + __v_5);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_3 + __v_7);
-        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_1, __v_6, __v_8]; 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 __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_6, __v_8]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_389] = [__v_9];
-        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_392] = [__v_9];
+        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36147,38 +35590,38 @@ fn aiur_fn_389(
   })
 }
 
-const INPUT_SIZE_390: usize = 5;
-const IN_390: usize = 5;
-const OUT_390: usize = 1;
-fn aiur_fn_390(
-  inp: [G; IN_390],
+const INPUT_SIZE_393: usize = 5;
+const IN_393: usize = 5;
+const OUT_393: usize = 1;
+fn aiur_fn_393(
+  inp: [G; IN_393],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_390], ExecError> {
+) -> Result<[G; OUT_393], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_3, __v_4]; 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 __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_3, __v_4]; 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_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_390] = [__v_6];
-        record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_393] = [__v_6];
+        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_1, __v_3, __v_4]; 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 __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_3, __v_4]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_390] = [__v_7];
-            record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_393] = [__v_7];
+            record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -36186,10 +35629,10 @@ fn aiur_fn_390(
             let __v_8: G = (__v_3 + __v_7);
             let __v_9: G = G::from_u64(1);
             let __v_10: G = (__v_4 + __v_9);
-            let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_2, __v_8, __v_10]; 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 __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_2, __v_8, __v_10]; 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_11: G = __r_arr[0];
-            let __ret: [G; OUT_390] = [__v_11];
-            record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_393] = [__v_11];
+            record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36204,60 +35647,60 @@ fn aiur_fn_390(
   })
 }
 
-const INPUT_SIZE_391: usize = 2;
-const IN_391: usize = 2;
-const OUT_391: usize = 1;
-fn aiur_fn_391(
-  inp: [G; IN_391],
+const INPUT_SIZE_394: usize = 2;
+const IN_394: usize = 2;
+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_391], ExecError> {
+) -> Result<[G; OUT_394], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_1, __v_2]; 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_2, __v_3]; 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 __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2, __v_3]; 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_4: G = __r_arr[0];
-    let __ret: [G; OUT_391] = [__v_4];
-    record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_394] = [__v_4];
+    record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_392: usize = 3;
-const IN_392: usize = 3;
-const OUT_392: usize = 1;
-fn aiur_fn_392(
-  inp: [G; IN_392],
+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_392], ExecError> {
+) -> Result<[G; OUT_395], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_2, __v_3, __v_2]; 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 __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_2, __v_3, __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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_4, __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_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_392] = { let __args: [G; IN_392] = [__v_0, __v_1, __v_5]; 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 __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1, __v_5]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_392] = [__v_7];
-        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_395] = [__v_7];
+        record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_392] = [__v_2];
-        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_395] = [__v_2];
+        record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36267,15 +35710,15 @@ fn aiur_fn_392(
   })
 }
 
-const INPUT_SIZE_393: usize = 4;
-const IN_393: usize = 4;
-const OUT_393: usize = 1;
-fn aiur_fn_393(
-  inp: [G; IN_393],
+const INPUT_SIZE_396: usize = 4;
+const IN_396: usize = 4;
+const OUT_396: usize = 1;
+fn aiur_fn_396(
+  inp: [G; IN_396],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_393], ExecError> {
+) -> Result<[G; OUT_396], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36284,26 +35727,26 @@ fn aiur_fn_393(
     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_393] = [__v_3];
-        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_396] = [__v_3];
+        record.function_queries[396].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_767] = { let __args: [G; IN_767] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = (__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_385] = { let __args: [G; IN_385] = [__v_3, __v_9]; 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 __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_3, __v_9]; 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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_1, __v_11, __v_12]; 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 __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_1, __v_11, __v_12]; 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_13: G = __r_arr[0];
-        let __ret: [G; OUT_393] = [__v_13];
-        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_396] = [__v_13];
+        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36313,15 +35756,15 @@ fn aiur_fn_393(
   })
 }
 
-const INPUT_SIZE_394: usize = 2;
-const IN_394: usize = 2;
-const OUT_394: usize = 1;
-fn aiur_fn_394(
-  inp: [G; IN_394],
+const INPUT_SIZE_397: usize = 2;
+const IN_397: usize = 2;
+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_394], ExecError> {
+) -> Result<[G; OUT_397], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36330,27 +35773,27 @@ fn aiur_fn_394(
         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_394] = [__v_4];
-        record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_397] = [__v_4];
+        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_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_394] = [__v_0];
-            record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_397] = [__v_0];
+            record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_1]; 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_4: G = __r_arr[0];
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[784].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_784] = unsafe { *(result.output.as_ptr() as *const [G; OUT_784]) }; __ret } else { aiur_fn_784(__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));
+            let __ret: [G; OUT_397] = [__v_5];
+            record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36362,40 +35805,40 @@ fn aiur_fn_394(
   })
 }
 
-const INPUT_SIZE_395: usize = 3;
-const IN_395: usize = 3;
-const OUT_395: usize = 1;
-fn aiur_fn_395(
-  inp: [G; IN_395],
+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_395], ExecError> {
+) -> Result<[G; OUT_398], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_395] = [__v_0];
-        record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_398] = [__v_0];
+        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0]; 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_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_395] = [__v_0];
-            record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_396] = { let __args: [G; IN_396] = [__v_0, __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 __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0, __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_5: G = __r_arr[0];
-            let __ret: [G; OUT_395] = [__v_5];
-            record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_398] = [__v_5];
+            record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36407,15 +35850,15 @@ fn aiur_fn_395(
   })
 }
 
-const INPUT_SIZE_396: usize = 3;
-const IN_396: usize = 3;
-const OUT_396: usize = 1;
-fn aiur_fn_396(
-  inp: [G; IN_396],
+const INPUT_SIZE_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_396], ExecError> {
+) -> Result<[G; OUT_399], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36430,8 +35873,8 @@ fn aiur_fn_396(
         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_396] = [__v_0];
-            record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_399] = [__v_0];
+            record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -36439,8 +35882,8 @@ fn aiur_fn_396(
             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_396] = [__v_11];
-            record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_399] = [__v_11];
+            record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36452,88 +35895,88 @@ fn aiur_fn_396(
         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_396] = [__v_9];
-        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_399] = [__v_9];
+        record.function_queries[399].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_396] = [__v_9];
-        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_399] = [__v_9];
+        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __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 __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_395] = { let __args: [G; IN_395] = [__v_5, __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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(0);
         let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_396] = [__v_11];
-        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_399] = [__v_11];
+        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __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 __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_395] = { let __args: [G; IN_395] = [__v_5, __v_1, __v_10]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_396] = [__v_13];
-        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_399] = [__v_13];
+        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __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 __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_395] = { let __args: [G; IN_395] = [__v_5, __v_1, __v_10]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_396] = [__v_13];
-        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_399] = [__v_13];
+        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(6);
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __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 __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_395] = { let __args: [G; IN_395] = [__v_5, __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 __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_395] = { let __args: [G; IN_395] = [__v_6, __v_1, __v_11]; 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 __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_396] = [__v_13];
-        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_399] = [__v_13];
+        record.function_queries[399].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_396] = [__v_9];
-        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_399] = [__v_9];
+        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_6, __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 __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_396] = [__v_9];
-        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_399] = [__v_9];
+        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36543,40 +35986,40 @@ fn aiur_fn_396(
   })
 }
 
-const INPUT_SIZE_397: usize = 3;
-const IN_397: usize = 3;
-const OUT_397: usize = 1;
-fn aiur_fn_397(
-  inp: [G; IN_397],
+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_397], ExecError> {
+) -> Result<[G; OUT_400], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_397] = [__v_0];
-        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_400] = [__v_0];
+        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0]; 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_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_397] = [__v_0];
-            record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_400] = [__v_0];
+            record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __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 __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0];
-            let __ret: [G; OUT_397] = [__v_5];
-            record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_400] = [__v_5];
+            record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36588,15 +36031,15 @@ fn aiur_fn_397(
   })
 }
 
-const INPUT_SIZE_398: usize = 3;
-const IN_398: usize = 3;
-const OUT_398: usize = 1;
-fn aiur_fn_398(
-  inp: [G; IN_398],
+const INPUT_SIZE_401: usize = 3;
+const IN_401: usize = 3;
+const OUT_401: usize = 1;
+fn aiur_fn_401(
+  inp: [G; IN_401],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_398], ExecError> {
+) -> Result<[G; OUT_401], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36611,8 +36054,8 @@ fn aiur_fn_398(
         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_398] = [__v_0];
-            record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_401] = [__v_0];
+            record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -36620,8 +36063,8 @@ fn aiur_fn_398(
             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_398] = [__v_11];
-            record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_401] = [__v_11];
+            record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36633,88 +36076,88 @@ fn aiur_fn_398(
         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_398] = [__v_9];
-        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_9];
+        record.function_queries[401].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_398] = [__v_9];
-        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_9];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_4, __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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_5, __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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __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_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_398] = [__v_11];
-        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_11];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_4, __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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __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_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_397] = { let __args: [G; IN_397] = [__v_5, __v_1, __v_10]; 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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_1, __v_10]; 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_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_398] = [__v_13];
-        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_13];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_4, __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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __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_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_397] = { let __args: [G; IN_397] = [__v_5, __v_1, __v_10]; 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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_1, __v_10]; 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_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_398] = [__v_13];
-        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_13];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(6);
-        let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_4, __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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_5, __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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __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_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_397] = { let __args: [G; IN_397] = [__v_6, __v_1, __v_11]; 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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_6, __v_1, __v_11]; 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_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_398] = [__v_13];
-        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_13];
+        record.function_queries[401].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_398] = [__v_9];
-        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_9];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_6, __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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_6, __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_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_398] = [__v_9];
-        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_9];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36724,33 +36167,33 @@ fn aiur_fn_398(
   })
 }
 
-const INPUT_SIZE_399: usize = 3;
-const IN_399: usize = 3;
-const OUT_399: usize = 1;
-fn aiur_fn_399(
-  inp: [G; IN_399],
+const INPUT_SIZE_402: usize = 3;
+const IN_402: usize = 3;
+const OUT_402: usize = 1;
+fn aiur_fn_402(
+  inp: [G; IN_402],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_399], ExecError> {
+) -> Result<[G; OUT_402], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0]; 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_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_399] = [__v_0];
-        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_402] = [__v_0];
+        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_399] = [__v_5];
-        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_402] = [__v_5];
+        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36760,15 +36203,15 @@ fn aiur_fn_399(
   })
 }
 
-const INPUT_SIZE_400: usize = 3;
-const IN_400: usize = 3;
-const OUT_400: usize = 1;
-fn aiur_fn_400(
-  inp: [G; IN_400],
+const INPUT_SIZE_403: usize = 3;
+const IN_403: usize = 3;
+const OUT_403: usize = 1;
+fn aiur_fn_403(
+  inp: [G; IN_403],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_400], ExecError> {
+) -> Result<[G; OUT_403], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36783,8 +36226,8 @@ fn aiur_fn_400(
         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_400] = [__v_0];
-            record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_403] = [__v_0];
+            record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -36792,10 +36235,10 @@ fn aiur_fn_400(
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2, __v_9]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_1, __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_400] = [__v_10];
-                record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_403] = [__v_10];
+                record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -36804,8 +36247,8 @@ fn aiur_fn_400(
                 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_400] = [__v_13];
-                record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_403] = [__v_13];
+                record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -36819,88 +36262,88 @@ fn aiur_fn_400(
         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));
+        let __ret: [G; OUT_403] = [__v_9];
+        record.function_queries[403].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));
+        let __ret: [G; OUT_403] = [__v_9];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_5, __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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_1, __v_2]; 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_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));
+        let __ret: [G; OUT_403] = [__v_11];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_4, __v_1, __v_2]; 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 = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_5, __v_1, __v_10]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_1, __v_10]; 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_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));
+        let __ret: [G; OUT_403] = [__v_13];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_4, __v_1, __v_2]; 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 = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_5, __v_1, __v_10]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_1, __v_10]; 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_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));
+        let __ret: [G; OUT_403] = [__v_13];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(6);
-        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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_5, __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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_1, __v_2]; 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_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_399] = { let __args: [G; IN_399] = [__v_6, __v_1, __v_11]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_6, __v_1, __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 = { 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));
+        let __ret: [G; OUT_403] = [__v_13];
+        record.function_queries[403].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));
+        let __ret: [G; OUT_403] = [__v_9];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_6, __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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_6, __v_1, __v_2]; 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 = { 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));
+        let __ret: [G; OUT_403] = [__v_9];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36910,33 +36353,33 @@ fn aiur_fn_400(
   })
 }
 
-const INPUT_SIZE_401: usize = 3;
-const IN_401: usize = 3;
-const OUT_401: usize = 1;
-fn aiur_fn_401(
-  inp: [G; IN_401],
+const INPUT_SIZE_404: usize = 3;
+const IN_404: usize = 3;
+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_401], ExecError> {
+) -> Result<[G; OUT_404], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0]; 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_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_401] = [__v_0];
-        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_404] = [__v_0];
+        record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_1, __v_2]; 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 __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_401] = [__v_5];
-        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_404] = [__v_5];
+        record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36946,15 +36389,15 @@ fn aiur_fn_401(
   })
 }
 
-const INPUT_SIZE_402: usize = 3;
-const IN_402: usize = 3;
-const OUT_402: usize = 1;
-fn aiur_fn_402(
-  inp: [G; IN_402],
+const INPUT_SIZE_405: usize = 3;
+const IN_405: usize = 3;
+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_402], ExecError> {
+) -> Result<[G; OUT_405], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36965,25 +36408,25 @@ fn aiur_fn_402(
         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_402] = [__v_6];
-        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_405] = [__v_6];
+        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; 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_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_767] = { let __args: [G; IN_767] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_2, __v_9]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_8, __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_402] = [__v_10];
-            record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_405] = [__v_10];
+            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -36991,8 +36434,8 @@ fn aiur_fn_402(
             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_402] = [__v_10];
-            record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_405] = [__v_10];
+            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37007,15 +36450,15 @@ fn aiur_fn_402(
   })
 }
 
-const INPUT_SIZE_403: usize = 3;
-const IN_403: usize = 3;
-const OUT_403: usize = 1;
-fn aiur_fn_403(
-  inp: [G; IN_403],
+const INPUT_SIZE_406: usize = 3;
+const IN_406: usize = 3;
+const OUT_406: usize = 1;
+fn aiur_fn_406(
+  inp: [G; IN_406],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_403], ExecError> {
+) -> Result<[G; OUT_406], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37027,98 +36470,98 @@ fn aiur_fn_403(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_4, __v_1, __v_2]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_403] = [__v_7];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_406] = [__v_7];
+        record.function_queries[406].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_403] = [__v_9];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_406] = [__v_9];
+        record.function_queries[406].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_403] = [__v_9];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_406] = [__v_9];
+        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __v_1, __v_2]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_5, __v_1, __v_2]; 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_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_403] = [__v_11];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_406] = [__v_11];
+        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __v_1, __v_2]; 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_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_401] = { let __args: [G; IN_401] = [__v_5, __v_1, __v_10]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_5, __v_1, __v_10]; 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 __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_403] = [__v_13];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_406] = [__v_13];
+        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __v_1, __v_2]; 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_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_401] = { let __args: [G; IN_401] = [__v_5, __v_1, __v_10]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_5, __v_1, __v_10]; 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 __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_403] = [__v_13];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_406] = [__v_13];
+        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(6);
-        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __v_1, __v_2]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_5, __v_1, __v_2]; 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_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_401] = { let __args: [G; IN_401] = [__v_6, __v_1, __v_11]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_6, __v_1, __v_11]; 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 __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_403] = [__v_13];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_406] = [__v_13];
+        record.function_queries[406].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_403] = [__v_9];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_406] = [__v_9];
+        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_6, __v_1, __v_2]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_6, __v_1, __v_2]; 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_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_403] = [__v_9];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_406] = [__v_9];
+        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37128,15 +36571,15 @@ fn aiur_fn_403(
   })
 }
 
-const INPUT_SIZE_404: usize = 2;
-const IN_404: usize = 2;
-const OUT_404: usize = 1;
-fn aiur_fn_404(
-  inp: [G; IN_404],
+const INPUT_SIZE_407: usize = 2;
+const IN_407: usize = 2;
+const OUT_407: usize = 1;
+fn aiur_fn_407(
+  inp: [G; IN_407],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_404], ExecError> {
+) -> Result<[G; OUT_407], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37146,18 +36589,18 @@ fn aiur_fn_404(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_404] = [__v_0];
-        record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_407] = [__v_0];
+        record.function_queries[407].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_404] = { let __args: [G; IN_404] = [__v_7, __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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_7, __v_4]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_404] = [__v_8];
-        record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_407] = [__v_8];
+        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37167,15 +36610,15 @@ fn aiur_fn_404(
   })
 }
 
-const INPUT_SIZE_405: usize = 3;
-const IN_405: usize = 3;
-const OUT_405: usize = 3;
-fn aiur_fn_405(
-  inp: [G; IN_405],
+const INPUT_SIZE_408: usize = 3;
+const IN_408: usize = 3;
+const OUT_408: usize = 3;
+fn aiur_fn_408(
+  inp: [G; IN_408],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_405], ExecError> {
+) -> Result<[G; OUT_408], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37195,17 +36638,17 @@ fn aiur_fn_405(
           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_405] = { let __args: [G; IN_405] = [__v_5, __v_9, __v_11]; 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 __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_5, __v_9, __v_11]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             let __v_14: G = __r_arr[2];
-            let __ret: [G; OUT_405] = [__v_12, __v_13, __v_14];
-            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_408] = [__v_12, __v_13, __v_14];
+            record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __ret: [G; OUT_405] = [__v_0, __v_2, __v_1];
-            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_408] = [__v_0, __v_2, __v_1];
+            record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37214,23 +36657,23 @@ fn aiur_fn_405(
         }
       },
       _ => {
-        let __ret: [G; OUT_405] = [__v_0, __v_2, __v_1];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_408] = [__v_0, __v_2, __v_1];
+        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_406: usize = 5;
-const IN_406: usize = 5;
-const OUT_406: usize = 1;
-fn aiur_fn_406(
-  inp: [G; IN_406],
+const INPUT_SIZE_409: usize = 5;
+const IN_409: usize = 5;
+const OUT_409: usize = 1;
+fn aiur_fn_409(
+  inp: [G; IN_409],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_406], ExecError> {
+) -> Result<[G; OUT_409], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37240,56 +36683,56 @@ fn aiur_fn_406(
     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_405] = { let __args: [G; IN_405] = [__v_1, __v_0, __v_7]; 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 __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_1, __v_0, __v_7]; 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_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
     let __v_10: G = __r_arr[2];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_9]; 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_11: G = __r_arr[0];
     match __v_11.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_0]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_1, __v_0]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_406] = [__v_12];
-        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_409] = [__v_12];
+        record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_8, __v_13, __v_14]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_8, __v_13, __v_14]; 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_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_15, __v_10, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_15, __v_10, __v_2, __v_3, __v_4]; 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_16: G = __r_arr[0];
-        let __ret: [G; OUT_406] = [__v_16];
-        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_409] = [__v_16];
+        record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_8, __v_9, __v_12]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_8, __v_9, __v_12]; 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_13, __v_10, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_13, __v_10, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0];
-        let __ret: [G; OUT_406] = [__v_14];
-        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_409] = [__v_14];
+        record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_407: usize = 5;
-const IN_407: usize = 5;
-const OUT_407: usize = 1;
-fn aiur_fn_407(
-  inp: [G; IN_407],
+const INPUT_SIZE_410: usize = 5;
+const IN_410: usize = 5;
+const OUT_410: usize = 1;
+fn aiur_fn_410(
+  inp: [G; IN_410],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_407], ExecError> {
+) -> Result<[G; OUT_410], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37303,68 +36746,68 @@ fn aiur_fn_407(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       3u64 => {
-        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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_9, __v_11, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_9, __v_11, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_407] = [__v_12];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_410] = [__v_12];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_1, __v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_1, __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_9: G = __r_arr[0];
-        let __ret: [G; OUT_407] = [__v_9];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_410] = [__v_9];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_6, __v_7, __v_0, __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 __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_407] = [__v_9];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_410] = [__v_9];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_8, __v_7, __v_9]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_8, __v_7, __v_9]; 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_407] = [__v_11];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_410] = [__v_11];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_6, __v_7, __v_8, __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 __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_6, __v_7, __v_8, __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_9: G = __r_arr[0];
-        let __ret: [G; OUT_407] = [__v_9];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_410] = [__v_9];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_0, __v_1]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_407] = [__v_9];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_410] = [__v_9];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_408: usize = 7;
-const IN_408: usize = 7;
-const OUT_408: usize = 1;
-fn aiur_fn_408(
-  inp: [G; IN_408],
+const INPUT_SIZE_411: usize = 7;
+const IN_411: usize = 7;
+const OUT_411: usize = 1;
+fn aiur_fn_411(
+  inp: [G; IN_411],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_408], ExecError> {
+) -> Result<[G; OUT_411], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37373,20 +36816,20 @@ 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_418] = { let __args: [G; IN_418] = [__v_2, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_2, __v_4, __v_5, __v_6]; 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_7]; 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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
-    let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_0, __v_1, __v_8, __v_9, __v_6]; 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 __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1, __v_8, __v_9, __v_6]; 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_11, __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 __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_11, __v_3, __v_4, __v_5, __v_6]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_408] = [__v_12];
-        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_411] = [__v_12];
+        record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -37397,7 +36840,7 @@ fn aiur_fn_408(
         let __v_15: G = __loaded[3];
         match __v_12.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
             let __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];
@@ -37414,21 +36857,21 @@ fn aiur_fn_408(
             match __v_17.as_canonical_u64() {
               6u64 => {
                 let __v_28: G = (__v_22 + __v_1);
-                let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_9, __v_28]; 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 __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_9, __v_28]; 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_29: G = __r_arr[0];
-                let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_29, __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 __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_29, __v_3, __v_4, __v_5, __v_6]; 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_30: G = __r_arr[0];
-                let __ret: [G; OUT_408] = [__v_30];
-                record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_411] = [__v_30];
+                record.function_queries[411].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_404] = { let __args: [G; IN_404] = [__v_29, __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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_29, __v_3]; 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_30: G = __r_arr[0];
-                let __ret: [G; OUT_408] = [__v_30];
-                record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_411] = [__v_30];
+                record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -37436,10 +36879,10 @@ fn aiur_fn_408(
           _ => {
             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_404] = { let __args: [G; IN_404] = [__v_17, __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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_17, __v_3]; 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_18: G = __r_arr[0];
-            let __ret: [G; OUT_408] = [__v_18];
-            record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_411] = [__v_18];
+            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -37451,15 +36894,15 @@ fn aiur_fn_408(
   })
 }
 
-const INPUT_SIZE_409: usize = 5;
-const IN_409: usize = 5;
-const OUT_409: usize = 2;
-fn aiur_fn_409(
-  inp: [G; IN_409],
+const INPUT_SIZE_412: usize = 5;
+const IN_412: usize = 5;
+const OUT_412: usize = 2;
+fn aiur_fn_412(
+  inp: [G; IN_412],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_409], ExecError> {
+) -> Result<[G; OUT_412], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37473,19 +36916,19 @@ fn aiur_fn_409(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+        let __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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_9, __v_10]; 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
+        let __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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_9, __v_12]; 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __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_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_9, __v_14]; 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_15: G = __r_arr[0];
         let __v_16: G = (__v_13 + __v_15);
         let __v_17: G = (__v_11 + __v_16);
@@ -37496,26 +36939,26 @@ fn aiur_fn_409(
             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_409] = [__v_18, __v_22];
-            record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_412] = [__v_18, __v_22];
+            record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; 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_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_767] = { let __args: [G; IN_767] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_20: G = __r_arr[0];
-                let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_20, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_20, __v_2, __v_3, __v_4]; 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_21: G = __r_arr[0];
                 let __v_22: G = G::from_u64(1);
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_23, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_23, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0];
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_24, __v_4]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_24, __v_4]; 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_25: G = __r_arr[0];
                 let __v_26: G = __r_arr[1];
                 match __v_25.as_canonical_u64() {
@@ -37525,22 +36968,22 @@ fn aiur_fn_409(
                     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_409] = [__v_27, __v_31];
-                    record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_412] = [__v_27, __v_31];
+                    record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_26]; 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 __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_26]; 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_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_26]; 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 __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_26]; 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_28: G = __r_arr[0];
-                    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_28]; 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 __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_28]; 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_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_338] = { let __args: [G; IN_338] = [__v_21, __v_4]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_21, __v_4]; 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_32: G = __r_arr[0];
                         let __v_33: G = __r_arr[1];
                         match __v_32.as_canonical_u64() {
@@ -37550,8 +36993,8 @@ fn aiur_fn_409(
                             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_409] = [__v_34, __v_38];
-                            record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_412] = [__v_34, __v_38];
+                            record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
@@ -37560,12 +37003,12 @@ fn aiur_fn_409(
                             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_340] = { let __args: [G; IN_340] = [__v_26]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_26]; 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_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_409] = [__v_34, __v_41];
-                            record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_412] = [__v_34, __v_41];
+                            record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -37579,8 +37022,8 @@ fn aiur_fn_409(
                         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_409] = [__v_32, __v_36];
-                        record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_412] = [__v_32, __v_36];
+                        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -37596,8 +37039,8 @@ fn aiur_fn_409(
                 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_409] = [__v_19, __v_23];
-                record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_412] = [__v_19, __v_23];
+                record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -37610,23 +37053,23 @@ fn aiur_fn_409(
         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_409] = [__v_9, __v_13];
-        record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_412] = [__v_9, __v_13];
+        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_410: usize = 7;
-const IN_410: usize = 7;
-const OUT_410: usize = 2;
-fn aiur_fn_410(
-  inp: [G; IN_410],
+const INPUT_SIZE_413: usize = 7;
+const IN_413: usize = 7;
+const OUT_413: usize = 2;
+fn aiur_fn_413(
+  inp: [G; IN_413],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_410], ExecError> {
+) -> Result<[G; OUT_413], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37635,58 +37078,58 @@ fn aiur_fn_410(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0, __v_3, __v_4, __v_5, __v_6]; 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_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_410] = [__v_9, __v_8];
-        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_413] = [__v_9, __v_8];
+        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_3, __v_6]; 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 __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_3, __v_6]; 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_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_410] = [__v_11, __v_10];
-            record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_413] = [__v_11, __v_10];
+            record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_3, __v_4, __v_5, __v_6]; 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];
             match __v_11.as_canonical_u64() {
               1u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __ret: [G; OUT_410] = [__v_13, __v_12];
-                record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_413] = [__v_13, __v_12];
+                record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_3, __v_4, __v_5, __v_6]; 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_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_410] = [__v_15, __v_14];
-                    record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_413] = [__v_15, __v_14];
+                    record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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_410] = [__v_17, __v_16];
-                        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_413] = [__v_17, __v_16];
+                        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
@@ -37695,8 +37138,8 @@ fn aiur_fn_410(
                         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_410] = [__v_17, __v_21];
-                        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_413] = [__v_17, __v_21];
+                        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -37726,15 +37169,15 @@ fn aiur_fn_410(
   })
 }
 
-const INPUT_SIZE_411: usize = 7;
-const IN_411: usize = 7;
-const OUT_411: usize = 1;
-fn aiur_fn_411(
-  inp: [G; IN_411],
+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_411], ExecError> {
+) -> Result<[G; OUT_414], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37743,9 +37186,9 @@ fn aiur_fn_411(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_6, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_6, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __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];
@@ -37761,22 +37204,22 @@ fn aiur_fn_411(
     let __v_19: G = __loaded[10];
     match __v_9.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__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[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 __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__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[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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         match __v_20.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_21, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_21, __v_4, __v_5, __v_6]; 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_411] = [__v_22];
-            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_404] = { let __args: [G; IN_404] = [__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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_2, __v_3]; 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_411] = [__v_22];
-            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_414] = [__v_22];
+            record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37785,22 +37228,22 @@ fn aiur_fn_411(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_12, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_12, __v_3, __v_4, __v_5, __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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         match __v_20.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_21, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_21, __v_4, __v_5, __v_6]; 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_411] = [__v_22];
-            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_404] = { let __args: [G; IN_404] = [__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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_2, __v_3]; 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_411] = [__v_22];
-            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_414] = [__v_22];
+            record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37809,11 +37252,11 @@ fn aiur_fn_411(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_7]; 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 __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_7]; 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_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_410] = { let __args: [G; IN_410] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; 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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     break '__mc_0 [__v_21, __v_22];
@@ -37832,43 +37275,43 @@ fn aiur_fn_411(
         let __v_22: G = __mc_out___mc_0[1];
         match __v_21.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_22, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_22, __v_4, __v_5, __v_6]; 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_23: G = __r_arr[0];
-            let __ret: [G; OUT_411] = [__v_23];
-            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_380] = { let __args: [G; IN_380] = [__v_0, __v_3, __v_5]; 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 __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_3, __v_5]; 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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             match __v_23.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_24, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_24, __v_4, __v_5, __v_6]; 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_25: G = __r_arr[0];
-                let __ret: [G; OUT_411] = [__v_25];
-                record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_414] = [__v_25];
+                record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_2, __v_3, __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 __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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_25: G = __r_arr[0];
                     let __v_26: G = __r_arr[1];
                     match __v_25.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_411] = [__v_26];
-                        record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_414] = [__v_26];
+                        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_12, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_12, __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_27: G = __r_arr[0];
-                        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_27, __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 __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_27, __v_3, __v_4, __v_5, __v_6]; 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_28: G = __r_arr[0];
-                        let __ret: [G; OUT_411] = [__v_28];
-                        record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_414] = [__v_28];
+                        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -37877,17 +37320,17 @@ fn aiur_fn_411(
                     }
                   },
                   2u64 => {
-                    let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_2, __v_3]; 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_25: G = __r_arr[0];
-                    let __ret: [G; OUT_411] = [__v_25];
-                    record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_414] = [__v_25];
+                    record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_2, __v_3]; 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_25: G = __r_arr[0];
-                    let __ret: [G; OUT_411] = [__v_25];
-                    record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_414] = [__v_25];
+                    record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -37906,15 +37349,15 @@ fn aiur_fn_411(
   })
 }
 
-const INPUT_SIZE_412: usize = 4;
-const IN_412: usize = 4;
-const OUT_412: usize = 1;
-fn aiur_fn_412(
-  inp: [G; IN_412],
+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_412], ExecError> {
+) -> Result<[G; OUT_415], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37927,79 +37370,79 @@ fn aiur_fn_412(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_412] = [__v_0];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_412] = [__v_0];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_412] = [__v_0];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_412] = [__v_0];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_412] = [__v_0];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_383] = { let __args: [G; IN_383] = [__v_0]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_8]; 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 __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_8]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_9, __v_2, __v_3]; 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 __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_412] = [__v_10];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_415] = [__v_10];
+        record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_413: usize = 4;
-const IN_413: usize = 4;
-const OUT_413: usize = 1;
-fn aiur_fn_413(
-  inp: [G; IN_413],
+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_413], ExecError> {
+) -> Result<[G; OUT_416], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_5, __v_1, __v_2, __v_3]; 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_6: G = __r_arr[0];
-    let __ret: [G; OUT_413] = [__v_6];
-    record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_416] = [__v_6];
+    record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_414: usize = 5;
-const IN_414: usize = 5;
-const OUT_414: usize = 1;
-fn aiur_fn_414(
-  inp: [G; IN_414],
+const INPUT_SIZE_417: usize = 5;
+const IN_417: usize = 5;
+const OUT_417: usize = 1;
+fn aiur_fn_417(
+  inp: [G; IN_417],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_414], ExecError> {
+) -> Result<[G; OUT_417], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38013,68 +37456,68 @@ fn aiur_fn_414(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       3u64 => {
-        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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_11, __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 __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_9, __v_11, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_414] = [__v_12];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_12];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_1, __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 __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_1, __v_0, __v_2, __v_3, __v_4]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_414] = [__v_9];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_9];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_414] = [__v_9];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_9];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_8, __v_7, __v_9]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_8, __v_7, __v_9]; 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_10, __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 __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_414] = [__v_11];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_11];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_414] = [__v_9];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_9];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_0, __v_1]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_414] = [__v_9];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_9];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_415: usize = 5;
-const IN_415: usize = 5;
-const OUT_415: usize = 1;
-fn aiur_fn_415(
-  inp: [G; IN_415],
+const INPUT_SIZE_418: usize = 5;
+const IN_418: usize = 5;
+const OUT_418: usize = 1;
+fn aiur_fn_418(
+  inp: [G; IN_418],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_415], ExecError> {
+) -> Result<[G; OUT_418], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38084,56 +37527,56 @@ fn aiur_fn_415(
     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_405] = { let __args: [G; IN_405] = [__v_1, __v_0, __v_7]; 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 __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_1, __v_0, __v_7]; 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_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
     let __v_10: G = __r_arr[2];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_9]; 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_11: G = __r_arr[0];
     match __v_11.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_0]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_1, __v_0]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_415] = [__v_12];
-        record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_418] = [__v_12];
+        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_8, __v_13, __v_14]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_8, __v_13, __v_14]; 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_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_15, __v_10, __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 __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_15, __v_10, __v_2, __v_3, __v_4]; 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_16: G = __r_arr[0];
-        let __ret: [G; OUT_415] = [__v_16];
-        record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_418] = [__v_16];
+        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_8, __v_9, __v_12]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_8, __v_9, __v_12]; 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_10, __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 __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_13, __v_10, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0];
-        let __ret: [G; OUT_415] = [__v_14];
-        record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_418] = [__v_14];
+        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_416: usize = 7;
-const IN_416: usize = 7;
-const OUT_416: usize = 1;
-fn aiur_fn_416(
-  inp: [G; IN_416],
+const INPUT_SIZE_419: usize = 7;
+const IN_419: usize = 7;
+const OUT_419: usize = 1;
+fn aiur_fn_419(
+  inp: [G; IN_419],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_416], ExecError> {
+) -> Result<[G; OUT_419], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38142,20 +37585,20 @@ fn aiur_fn_416(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_2, __v_4, __v_5, __v_6]; 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 __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_198] = { let __args: [G; IN_198] = [__v_7]; 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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
-    let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_0, __v_1, __v_8, __v_9, __v_6]; 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 __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1, __v_8, __v_9, __v_6]; 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_11, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_11, __v_3, __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_12: G = __r_arr[0];
-        let __ret: [G; OUT_416] = [__v_12];
-        record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_419] = [__v_12];
+        record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -38166,7 +37609,7 @@ fn aiur_fn_416(
         let __v_15: G = __loaded[3];
         match __v_12.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
             let __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];
@@ -38183,21 +37626,21 @@ fn aiur_fn_416(
             match __v_17.as_canonical_u64() {
               6u64 => {
                 let __v_28: G = (__v_22 + __v_1);
-                let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_9, __v_28]; 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 __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_9, __v_28]; 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_29: G = __r_arr[0];
-                let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_29, __v_3, __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_30: G = __r_arr[0];
-                let __ret: [G; OUT_416] = [__v_30];
-                record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_419] = [__v_30];
+                record.function_queries[419].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_404] = { let __args: [G; IN_404] = [__v_29, __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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_29, __v_3]; 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_30: G = __r_arr[0];
-                let __ret: [G; OUT_416] = [__v_30];
-                record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_419] = [__v_30];
+                record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -38205,10 +37648,10 @@ fn aiur_fn_416(
           _ => {
             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_404] = { let __args: [G; IN_404] = [__v_17, __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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_17, __v_3]; 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_18: G = __r_arr[0];
-            let __ret: [G; OUT_416] = [__v_18];
-            record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_419] = [__v_18];
+            record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -38220,15 +37663,15 @@ fn aiur_fn_416(
   })
 }
 
-const INPUT_SIZE_417: usize = 7;
-const IN_417: usize = 7;
-const OUT_417: usize = 1;
-fn aiur_fn_417(
-  inp: [G; IN_417],
+const INPUT_SIZE_420: usize = 7;
+const IN_420: usize = 7;
+const OUT_420: usize = 1;
+fn aiur_fn_420(
+  inp: [G; IN_420],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_417], ExecError> {
+) -> Result<[G; OUT_420], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38237,9 +37680,9 @@ fn aiur_fn_417(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_6, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_6, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __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];
@@ -38255,22 +37698,22 @@ fn aiur_fn_417(
     let __v_19: G = __loaded[10];
     match __v_9.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__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[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 __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__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[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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         match __v_20.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_21, __v_4, __v_5, __v_6]; 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 __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_417] = [__v_22];
-            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_420] = [__v_22];
+            record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_2, __v_3]; 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_417] = [__v_22];
-            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_420] = [__v_22];
+            record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38279,22 +37722,22 @@ fn aiur_fn_417(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_12, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_12, __v_3, __v_4, __v_5, __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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         match __v_20.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_21, __v_4, __v_5, __v_6]; 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 __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_417] = [__v_22];
-            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_420] = [__v_22];
+            record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_2, __v_3]; 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_417] = [__v_22];
-            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_420] = [__v_22];
+            record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38303,11 +37746,11 @@ fn aiur_fn_417(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_7]; 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 __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_7]; 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_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_410] = { let __args: [G; IN_410] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; 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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     break '__mc_0 [__v_21, __v_22];
@@ -38326,29 +37769,29 @@ fn aiur_fn_417(
         let __v_22: G = __mc_out___mc_0[1];
         match __v_21.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_22, __v_4, __v_5, __v_6]; 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 __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_417] = [__v_23];
-            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_420] = [__v_23];
+            record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_3, __v_5]; 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 __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_3, __v_5]; 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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             match __v_23.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_24, __v_4, __v_5, __v_6]; 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 __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_417] = [__v_25];
-                record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_420] = [__v_25];
+                record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_2, __v_3]; 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_25: G = __r_arr[0];
-                let __ret: [G; OUT_417] = [__v_25];
-                record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_420] = [__v_25];
+                record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -38365,15 +37808,15 @@ fn aiur_fn_417(
   })
 }
 
-const INPUT_SIZE_418: usize = 4;
-const IN_418: usize = 4;
-const OUT_418: usize = 1;
-fn aiur_fn_418(
-  inp: [G; IN_418],
+const INPUT_SIZE_421: usize = 4;
+const IN_421: usize = 4;
+const OUT_421: usize = 1;
+fn aiur_fn_421(
+  inp: [G; IN_421],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_418], ExecError> {
+) -> Result<[G; OUT_421], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38386,79 +37829,79 @@ fn aiur_fn_418(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_418] = [__v_0];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_421] = [__v_0];
+        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_418] = [__v_0];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_421] = [__v_0];
+        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_418] = [__v_0];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_421] = [__v_0];
+        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_418] = [__v_0];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_421] = [__v_0];
+        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_418] = [__v_0];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_421] = [__v_0];
+        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_8]; 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 __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_8]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_0, __v_9, __v_2, __v_3]; 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 __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_9, __v_2, __v_3]; 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_418] = [__v_10];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_421] = [__v_10];
+        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_419: usize = 4;
-const IN_419: usize = 4;
-const OUT_419: usize = 1;
-fn aiur_fn_419(
-  inp: [G; IN_419],
+const INPUT_SIZE_422: usize = 4;
+const IN_422: usize = 4;
+const OUT_422: usize = 1;
+fn aiur_fn_422(
+  inp: [G; IN_422],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_419], ExecError> {
+) -> Result<[G; OUT_422], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_4, __v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_4, __v_5, __v_1, __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_6: G = __r_arr[0];
-    let __ret: [G; OUT_419] = [__v_6];
-    record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_422] = [__v_6];
+    record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_420: usize = 12;
-const IN_420: usize = 12;
-const OUT_420: usize = 2;
-fn aiur_fn_420(
-  inp: [G; IN_420],
+const INPUT_SIZE_423: usize = 12;
+const IN_423: usize = 12;
+const OUT_423: usize = 2;
+fn aiur_fn_423(
+  inp: [G; IN_423],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_420], ExecError> {
+) -> Result<[G; OUT_423], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38475,7 +37918,7 @@ fn aiur_fn_420(
     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_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !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_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() {
@@ -38485,21 +37928,21 @@ fn aiur_fn_420(
         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_420] = [__v_17, __v_21];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_423] = [__v_17, __v_21];
+        record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_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_424] = { let __args: [G; IN_424] = [__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[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 __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__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[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_19: G = __r_arr[0];
             let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_420] = [__v_19, __v_20];
-            record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_423] = [__v_19, __v_20];
+            record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38508,8 +37951,8 @@ fn aiur_fn_420(
             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_420] = [__v_19, __v_23];
-            record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_423] = [__v_19, __v_23];
+            record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -38521,15 +37964,15 @@ fn aiur_fn_420(
   })
 }
 
-const INPUT_SIZE_421: usize = 2;
-const IN_421: usize = 2;
-const OUT_421: usize = 1;
-fn aiur_fn_421(
-  inp: [G; IN_421],
+const INPUT_SIZE_424: usize = 2;
+const IN_424: usize = 2;
+const OUT_424: usize = 1;
+fn aiur_fn_424(
+  inp: [G; IN_424],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_421], ExecError> {
+) -> Result<[G; OUT_424], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38540,12 +37983,12 @@ fn aiur_fn_421(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       7u64 => {
-        let __ret: [G; OUT_421] = [__v_0];
-        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_424] = [__v_0];
+        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __v_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 };
@@ -38555,27 +37998,27 @@ fn aiur_fn_421(
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_6, __v_7, __v_1]; 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 __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_6, __v_7, __v_1]; 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_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_310] = { let __args: [G; IN_310] = [__v_14]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_14]; 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_15: G = __r_arr[0];
-                let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_15]; 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 __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__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];
                 match __v_16.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_421] = [__v_0];
-                    record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_424] = [__v_0];
+                    record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_13, __v_15, __v_1]; 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 __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_13, __v_15, __v_1]; 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_17: G = __r_arr[0];
-                    let __ret: [G; OUT_421] = [__v_17];
-                    record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_424] = [__v_17];
+                    record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -38584,15 +38027,15 @@ fn aiur_fn_421(
                 }
               },
               _ => {
-                let __ret: [G; OUT_421] = [__v_0];
-                record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_424] = [__v_0];
+                record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_421] = [__v_0];
-            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_424] = [__v_0];
+            record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -38601,15 +38044,15 @@ fn aiur_fn_421(
   })
 }
 
-const INPUT_SIZE_422: usize = 3;
-const IN_422: usize = 3;
-const OUT_422: usize = 3;
-fn aiur_fn_422(
-  inp: [G; IN_422],
+const INPUT_SIZE_425: usize = 3;
+const IN_425: usize = 3;
+const OUT_425: usize = 3;
+fn aiur_fn_425(
+  inp: [G; IN_425],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_422], ExecError> {
+) -> Result<[G; OUT_425], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38621,11 +38064,11 @@ fn aiur_fn_422(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __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 __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_7, __v_8]; 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_9: G = __r_arr[0];
         match __v_9.as_canonical_u64() {
           0u64 => {
@@ -38633,22 +38076,22 @@ fn aiur_fn_422(
             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_422] = [__v_10, __v_0, __v_13];
-            record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_425] = [__v_10, __v_0, __v_13];
+            record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; 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_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_767] = { let __args: [G; IN_767] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
                 let __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];
@@ -38660,8 +38103,8 @@ fn aiur_fn_422(
                     match __v_18.as_canonical_u64() {
                       0u64 => {
                         let __v_21: G = G::from_u64(1);
-                        let __ret: [G; OUT_422] = [__v_21, __v_14, __v_19];
-                        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_425] = [__v_21, __v_14, __v_19];
+                        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -38669,8 +38112,8 @@ fn aiur_fn_422(
                         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_422] = [__v_21, __v_0, __v_24];
-                        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_425] = [__v_21, __v_0, __v_24];
+                        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -38680,8 +38123,8 @@ fn aiur_fn_422(
                     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_422] = [__v_21, __v_0, __v_24];
-                    record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_425] = [__v_21, __v_0, __v_24];
+                    record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -38691,8 +38134,8 @@ fn aiur_fn_422(
                 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_422] = [__v_13, __v_0, __v_16];
-                record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_425] = [__v_13, __v_0, __v_16];
+                record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -38707,31 +38150,31 @@ fn aiur_fn_422(
         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_422] = [__v_7, __v_0, __v_10];
-        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_425] = [__v_7, __v_0, __v_10];
+        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_423: usize = 3;
-const IN_423: usize = 3;
-const OUT_423: usize = 1;
-fn aiur_fn_423(
-  inp: [G; IN_423],
+const INPUT_SIZE_426: usize = 3;
+const IN_426: usize = 3;
+const OUT_426: usize = 1;
+fn aiur_fn_426(
+  inp: [G; IN_426],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_423], ExecError> {
+) -> Result<[G; OUT_426], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    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 __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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_2, __v_4]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3, __v_2, __v_4]; 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     match __v_5.as_canonical_u64() {
@@ -38739,8 +38182,8 @@ fn aiur_fn_423(
         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_423] = [__v_9];
-        record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_426] = [__v_9];
+        record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -38757,9 +38200,9 @@ fn aiur_fn_423(
         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_311] = { let __args: [G; IN_311] = [__v_1, __v_19]; 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 __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_19]; 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_20]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_20]; 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_21: G = __r_arr[0];
         let __v_22: G = G::from_u64(2);
         let __v_23: G = G::from_u64(1);
@@ -38767,22 +38210,22 @@ fn aiur_fn_423(
         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_321] = { let __args: [G; IN_321] = [__v_21]; 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 __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_21]; 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_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_423] = [__v_31];
-            record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_426] = [__v_31];
+            record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            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 __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_29: G = __r_arr[0];
             let __v_30: G = G::from_u64(0);
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_29, __v_2, __v_30]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_29, __v_2, __v_30]; 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_31: G = __r_arr[0];
             let __v_32: G = __r_arr[1];
             match __v_31.as_canonical_u64() {
@@ -38790,8 +38233,8 @@ fn aiur_fn_423(
                 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_423] = [__v_35];
-                record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_426] = [__v_35];
+                record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
@@ -38814,8 +38257,8 @@ fn aiur_fn_423(
                 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_423] = [__v_51];
-                record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_426] = [__v_51];
+                record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -38835,15 +38278,15 @@ fn aiur_fn_423(
   })
 }
 
-const INPUT_SIZE_424: usize = 11;
-const IN_424: usize = 11;
-const OUT_424: usize = 2;
-fn aiur_fn_424(
-  inp: [G; IN_424],
+const INPUT_SIZE_427: usize = 11;
+const IN_427: usize = 11;
+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_424], ExecError> {
+) -> Result<[G; OUT_427], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38856,22 +38299,22 @@ fn aiur_fn_424(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__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[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 __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__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[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(1);
-        let __ret: [G; OUT_424] = [__v_13, __v_12];
-        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_427] = [__v_13, __v_12];
+        record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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_433] = { let __args: [G; IN_433] = [__v_13, __v_2, __v_6, __v_8, __v_9, __v_10]; 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 __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_13, __v_2, __v_6, __v_8, __v_9, __v_10]; 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_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
     match __v_14.as_canonical_u64() {
@@ -38895,17 +38338,17 @@ fn aiur_fn_424(
 }
  };
         let __v_14: G = __mc_out___mc_0[0];
-        let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_14, __v_10]; 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 __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_14, __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_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_15, __v_8, __v_9, __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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_15, __v_8, __v_9, __v_10]; 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_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_16, __v_10]; 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 __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_16, __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_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_17, __v_10]; 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 __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_17, __v_10]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_18, __v_10]; 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 __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_18, __v_10]; 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_19]; 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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !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_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 };
@@ -38915,7 +38358,7 @@ fn aiur_fn_424(
         let __v_25: G = __loaded[3];
         match __v_22.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_9, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_9, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_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];
@@ -38931,7 +38374,7 @@ fn aiur_fn_424(
             let __v_37: G = __loaded[10];
             match __v_27.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[786].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_786] = unsafe { *(result.output.as_ptr() as *const [G; OUT_786]) }; __ret } else { aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[789].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_789] = unsafe { *(result.output.as_ptr() as *const [G; OUT_789]) }; __ret } else { aiur_fn_789(__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() {
@@ -38941,12 +38384,12 @@ fn aiur_fn_424(
                     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));
+                    let __ret: [G; OUT_427] = [__v_40, __v_44];
+                    record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
                     let __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() {
@@ -38956,12 +38399,12 @@ fn aiur_fn_424(
                         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_424] = [__v_42, __v_46];
-                        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_427] = [__v_42, __v_46];
+                        record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_6, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } else { aiur_fn_779(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_6, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } else { aiur_fn_782(__args, record, io_buffer, __cu)? } };
                         let __v_42: G = __r_arr[0];
                         let __v_43: G = __r_arr[1];
                         let __v_44: G = __r_arr[2];
@@ -38969,26 +38412,26 @@ fn aiur_fn_424(
                           _ => {
                             let __v_45: G = (__v_3 + __v_4);
                             let __v_46: G = (__v_2 + __v_45);
-                            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[784].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_784] = unsafe { *(result.output.as_ptr() as *const [G; OUT_784]) }; __ret } else { aiur_fn_784(__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_785] = { let __args: [G; IN_785] = [__v_21, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_21, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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_785] = { let __args: [G; IN_785] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__args, record, io_buffer, __cu)? } };
                             let __v_52: G = __r_arr[0];
-                            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_44, __v_0]; 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_44, __v_0]; 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_53: G = __r_arr[0];
-                            let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_53, __v_47]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_53, __v_47]; 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_54: G = __r_arr[0];
-                            let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_54, __v_49]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_54, __v_49]; 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_55: G = __r_arr[0];
-                            let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_55, __v_52]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_55, __v_52]; 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_56: G = __r_arr[0];
                             let __v_57: G = G::from_u64(1);
-                            let __ret: [G; OUT_424] = [__v_57, __v_56];
-                            record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_427] = [__v_57, __v_56];
+                            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -39004,21 +38447,21 @@ fn aiur_fn_424(
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__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[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 __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__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[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_38: G = __r_arr[0];
                 let __v_39: G = __r_arr[1];
-                let __ret: [G; OUT_424] = [__v_38, __v_39];
-                record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_427] = [__v_38, __v_39];
+                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__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[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 __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__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[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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __ret: [G; OUT_424] = [__v_26, __v_27];
-            record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_427] = [__v_26, __v_27];
+            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -39030,15 +38473,15 @@ fn aiur_fn_424(
   })
 }
 
-const INPUT_SIZE_425: usize = 8;
-const IN_425: usize = 8;
-const OUT_425: usize = 2;
-fn aiur_fn_425(
-  inp: [G; IN_425],
+const INPUT_SIZE_428: usize = 8;
+const IN_428: usize = 8;
+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_425], ExecError> {
+) -> Result<[G; OUT_428], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -39057,16 +38500,16 @@ fn aiur_fn_425(
         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_425] = [__v_10, __v_14];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_428] = [__v_10, __v_14];
+        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_10, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_10, __v_5, __v_6, __v_7]; 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_7]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_11, __v_7]; 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         match __v_12.as_canonical_u64() {
@@ -39076,19 +38519,19 @@ fn aiur_fn_425(
             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_425] = [__v_14, __v_18];
-            record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_428] = [__v_14, __v_18];
+            record.function_queries[428].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_767] = { let __args: [G; IN_767] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_17, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_17, __v_5, __v_6, __v_7]; 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_18: G = __r_arr[0];
-            let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_18, __v_7]; 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 __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_18, __v_7]; 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_19: G = __r_arr[0];
             match __v_19.as_canonical_u64() {
               0u64 => {
@@ -39097,40 +38540,40 @@ fn aiur_fn_425(
                 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_425] = [__v_20, __v_24];
-                record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_428] = [__v_20, __v_24];
+                record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_20: G = __r_arr[0];
-                let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_20, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_20, __v_5, __v_6, __v_7]; 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_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_785] = { let __args: [G; IN_785] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__args, record, io_buffer, __cu)? } };
                 let __v_24: G = __r_arr[0];
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_21, __v_7]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_21, __v_7]; 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_25: G = __r_arr[0];
                 let __v_26: G = __r_arr[1];
                 match __v_25.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_13]; 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 __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_13]; 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_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_404] = { let __args: [G; IN_404] = [__v_21, __v_24]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_21, __v_24]; 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_29: G = __r_arr[0];
-                        let __ret: [G; OUT_425] = [__v_28, __v_29];
-                        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_428] = [__v_28, __v_29];
+                        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        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 __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_28: G = __r_arr[0];
                         let __v_29: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_28, __v_7, __v_29]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_28, __v_7, __v_29]; 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_30: G = __r_arr[0];
                         let __v_31: G = __r_arr[1];
                         match __v_30.as_canonical_u64() {
@@ -39140,8 +38583,8 @@ fn aiur_fn_425(
                             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_425] = [__v_32, __v_36];
-                            record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_428] = [__v_32, __v_36];
+                            record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           1u64 => {
@@ -39155,15 +38598,15 @@ fn aiur_fn_425(
                             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_340] = { let __args: [G; IN_340] = [__v_13]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_13]; 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_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_404] = { let __args: [G; IN_404] = [__v_44, __v_24]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_44, __v_24]; 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_46: G = __r_arr[0];
-                            let __ret: [G; OUT_425] = [__v_45, __v_46];
-                            record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_428] = [__v_45, __v_46];
+                            record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -39178,14 +38621,14 @@ fn aiur_fn_425(
                   },
                   1u64 => {
                     let __v_27: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_26, __v_13]; 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 __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_26, __v_13]; 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_28: G = __r_arr[0];
-                    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_28]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_28]; 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_29: G = __r_arr[0];
-                    let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_29, __v_24]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_29, __v_24]; 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_30: G = __r_arr[0];
-                    let __ret: [G; OUT_425] = [__v_27, __v_30];
-                    record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_428] = [__v_27, __v_30];
+                    record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -39210,15 +38653,15 @@ fn aiur_fn_425(
   })
 }
 
-const INPUT_SIZE_426: usize = 2;
-const IN_426: usize = 2;
-const OUT_426: usize = 1;
-fn aiur_fn_426(
-  inp: [G; IN_426],
+const INPUT_SIZE_429: usize = 2;
+const IN_429: usize = 2;
+const OUT_429: usize = 1;
+fn aiur_fn_429(
+  inp: [G; IN_429],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_426], ExecError> {
+) -> Result<[G; OUT_429], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -39236,7 +38679,7 @@ fn aiur_fn_426(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           4u64 => {
-            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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__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];
             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 };
@@ -39246,28 +38689,28 @@ fn aiur_fn_426(
             let __v_15: G = __loaded[3];
             match __v_12.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
-                let __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 __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_17: G = __r_arr[0];
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
                 match __v_18.as_canonical_u64() {
                   0u64 => {
                     let __v_19: G = G::from_u64(0);
-                    let __ret: [G; OUT_426] = [__v_19];
-                    record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_429] = [__v_19];
+                    record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_11]; 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_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_767] = { let __args: [G; IN_767] = [__v_11, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                         let __v_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];
@@ -39277,22 +38720,22 @@ fn aiur_fn_426(
                         match __v_24.as_canonical_u64() {
                           0u64 => {
                             let __v_28: G = G::from_bool((__v_25 == G::ZERO));
-                            let __ret: [G; OUT_426] = [__v_28];
-                            record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_429] = [__v_28];
+                            record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_28: G = G::from_u64(0);
-                            let __ret: [G; OUT_426] = [__v_28];
-                            record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_429] = [__v_28];
+                            record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_22: G = G::from_u64(0);
-                        let __ret: [G; OUT_426] = [__v_22];
-                        record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_429] = [__v_22];
+                        record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -39304,39 +38747,39 @@ fn aiur_fn_426(
               },
               _ => {
                 let __v_16: G = G::from_u64(0);
-                let __ret: [G; OUT_426] = [__v_16];
-                record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_429] = [__v_16];
+                record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_426] = [__v_10];
-            record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_429] = [__v_10];
+            record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_426] = [__v_6];
-        record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_429] = [__v_6];
+        record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_427: usize = 10;
-const IN_427: usize = 10;
-const OUT_427: usize = 2;
-fn aiur_fn_427(
-  inp: [G; IN_427],
+const INPUT_SIZE_430: usize = 10;
+const IN_430: usize = 10;
+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_427], ExecError> {
+) -> Result<[G; OUT_430], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -39348,18 +38791,18 @@ fn aiur_fn_427(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[786].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_786] = unsafe { *(result.output.as_ptr() as *const [G; OUT_786]) }; __ret } else { aiur_fn_786(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[789].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_789] = unsafe { *(result.output.as_ptr() as *const [G; OUT_789]) }; __ret } else { aiur_fn_789(__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_779] = { let __args: [G; IN_779] = [__v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } else { aiur_fn_779(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } else { aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_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_767] = { let __args: [G; IN_767] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_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];
@@ -39375,7 +38818,7 @@ fn aiur_fn_427(
             let __v_26: G = __loaded[10];
             match __v_16.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_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];
@@ -39391,21 +38834,21 @@ fn aiur_fn_427(
                 let __v_38: G = __loaded[10];
                 match __v_28.as_canonical_u64() {
                   5u64 => {
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_33]; 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_39: G = __r_arr[0];
                     match __v_39.as_canonical_u64() {
                       1u64 => {
                         match __v_32.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_19, __v_8]; 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 __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_19, __v_8]; 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_40: G = __r_arr[0];
                             match __v_40.as_canonical_u64() {
                               0u64 => {
-                                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                                 let __v_41: G = __r_arr[0];
-                                let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_41, __v_7, __v_8, __v_9]; 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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_41, __v_7, __v_8, __v_9]; 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_42: G = __r_arr[0];
-                                let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_42, __v_7, __v_8, __v_9]; 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 __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_42, __v_7, __v_8, __v_9]; 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_43: G = __r_arr[0];
                                 match __v_43.as_canonical_u64() {
                                   1u64 => {
@@ -39414,31 +38857,31 @@ fn aiur_fn_427(
                                     let __v_46: G = G::from_u64(0);
                                     let __v_47: G = G::from_u64(0);
                                     let __v_48: G = { let __values: [G; 4] = [__v_45, __v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __ret: [G; OUT_427] = [__v_44, __v_48];
-                                    record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_430] = [__v_44, __v_48];
+                                    record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   0u64 => {
-                                    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_14, __v_6]; 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_14, __v_6]; 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_44: G = __r_arr[0];
                                     let __v_45: G = (__v_1 + __v_2);
                                     let __v_46: G = (__v_45 + __v_3);
-                                    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_0, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[784].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_784] = unsafe { *(result.output.as_ptr() as *const [G; OUT_784]) }; __ret } else { aiur_fn_784(__args, record, io_buffer, __cu)? } };
                                     let __v_47: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_44, __v_47]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_44, __v_47]; 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_48: G = __r_arr[0];
                                     let __v_49: G = G::from_u64(0);
-                                    let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_48, __v_19, __v_41, __v_13, __v_49]; 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 __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_48, __v_19, __v_41, __v_13, __v_49]; 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_50: G = __r_arr[0];
                                     let __v_51: G = G::from_u64(1);
                                     let __v_52: G = (__v_4 + __v_51);
-                                    let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_0, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_0, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__args, record, io_buffer, __cu)? } };
                                     let __v_53: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_50, __v_53]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_50, __v_53]; 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_54: G = __r_arr[0];
                                     let __v_55: G = G::from_u64(1);
-                                    let __ret: [G; OUT_427] = [__v_55, __v_54];
-                                    record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_430] = [__v_55, __v_54];
+                                    record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -39452,8 +38895,8 @@ fn aiur_fn_427(
                                 let __v_43: G = G::from_u64(0);
                                 let __v_44: G = G::from_u64(0);
                                 let __v_45: G = { let __values: [G; 4] = [__v_42, __v_43, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_427] = [__v_41, __v_45];
-                                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_430] = [__v_41, __v_45];
+                                record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -39464,8 +38907,8 @@ fn aiur_fn_427(
                             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_427] = [__v_40, __v_44];
-                            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_430] = [__v_40, __v_44];
+                            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -39476,8 +38919,8 @@ fn aiur_fn_427(
                         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_427] = [__v_40, __v_44];
-                        record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_430] = [__v_40, __v_44];
+                        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -39500,23 +38943,23 @@ fn aiur_fn_427(
         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_427] = [__v_11, __v_15];
-        record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_430] = [__v_11, __v_15];
+        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_428: usize = 5;
-const IN_428: usize = 5;
-const OUT_428: usize = 2;
-fn aiur_fn_428(
-  inp: [G; IN_428],
+const INPUT_SIZE_431: usize = 5;
+const IN_431: usize = 5;
+const OUT_431: usize = 2;
+fn aiur_fn_431(
+  inp: [G; IN_431],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_428], ExecError> {
+) -> Result<[G; OUT_431], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -39525,19 +38968,19 @@ fn aiur_fn_428(
     let __v_4: G = inp[4];
     match __v_0.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_428] = [__v_5, __v_6];
-        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_431] = [__v_5, __v_6];
+        record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_1, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_428] = [__v_5, __v_6];
-        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_431] = [__v_5, __v_6];
+        record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -39546,29 +38989,29 @@ fn aiur_fn_428(
         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_428] = [__v_5, __v_9];
-        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_431] = [__v_5, __v_9];
+        record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_429: usize = 4;
-const IN_429: usize = 4;
-const OUT_429: usize = 2;
-fn aiur_fn_429(
-  inp: [G; IN_429],
+const INPUT_SIZE_432: usize = 4;
+const IN_432: usize = 4;
+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_429], ExecError> {
+) -> Result<[G; OUT_432], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_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 };
@@ -39579,33 +39022,33 @@ fn aiur_fn_429(
         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_429] = [__v_7, __v_11];
-        record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_432] = [__v_7, __v_11];
+        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(5);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_10, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_10, __v_1, __v_2, __v_3]; 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_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_785] = { let __args: [G; IN_785] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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_404] = { let __args: [G; IN_404] = [__v_17, __v_14]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_17, __v_14]; 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_18: G = __r_arr[0];
             let __v_19: G = G::from_u64(1);
-            let __ret: [G; OUT_429] = [__v_19, __v_18];
-            record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_432] = [__v_19, __v_18];
+            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -39614,8 +39057,8 @@ fn aiur_fn_429(
             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_429] = [__v_13, __v_17];
-            record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_432] = [__v_13, __v_17];
+            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -39630,21 +39073,21 @@ fn aiur_fn_429(
   })
 }
 
-const INPUT_SIZE_430: usize = 4;
-const IN_430: usize = 4;
-const OUT_430: usize = 2;
-fn aiur_fn_430(
-  inp: [G; IN_430],
+const INPUT_SIZE_433: usize = 4;
+const IN_433: usize = 4;
+const OUT_433: usize = 2;
+fn aiur_fn_433(
+  inp: [G; IN_433],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_430], ExecError> {
+) -> Result<[G; OUT_433], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_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 };
@@ -39655,33 +39098,33 @@ fn aiur_fn_430(
         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_430] = [__v_7, __v_11];
-        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_433] = [__v_7, __v_11];
+        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(4);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_10, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_10, __v_1, __v_2, __v_3]; 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_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_785] = { let __args: [G; IN_785] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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_404] = { let __args: [G; IN_404] = [__v_17, __v_14]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_17, __v_14]; 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_18: G = __r_arr[0];
             let __v_19: G = G::from_u64(1);
-            let __ret: [G; OUT_430] = [__v_19, __v_18];
-            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_433] = [__v_19, __v_18];
+            record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -39690,8 +39133,8 @@ fn aiur_fn_430(
             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_430] = [__v_13, __v_17];
-            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_433] = [__v_13, __v_17];
+            record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -39706,23 +39149,23 @@ fn aiur_fn_430(
   })
 }
 
-const INPUT_SIZE_431: usize = 4;
-const IN_431: usize = 4;
-const OUT_431: usize = 2;
-fn aiur_fn_431(
-  inp: [G; IN_431],
+const INPUT_SIZE_434: usize = 4;
+const IN_434: usize = 4;
+const OUT_434: usize = 2;
+fn aiur_fn_434(
+  inp: [G; IN_434],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_431], ExecError> {
+) -> Result<[G; OUT_434], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_1, __v_2, __v_3]; 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_4]; 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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __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 };
@@ -39732,7 +39175,7 @@ fn aiur_fn_431(
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __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];
@@ -39750,18 +39193,18 @@ fn aiur_fn_431(
           4u64 => {
             match __v_15.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
                 let __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_767] = { let __args: [G; IN_767] = [__v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                     let __v_27: G = __r_arr[0];
                     let __v_28: G = G::from_u64(1);
-                    let __ret: [G; OUT_431] = [__v_28, __v_27];
-                    record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_434] = [__v_28, __v_27];
+                    record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -39770,8 +39213,8 @@ fn aiur_fn_431(
                     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_431] = [__v_26, __v_30];
-                    record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_434] = [__v_26, __v_30];
+                    record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -39782,8 +39225,8 @@ fn aiur_fn_431(
                 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_431] = [__v_23, __v_27];
-                record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_434] = [__v_23, __v_27];
+                record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -39794,8 +39237,8 @@ fn aiur_fn_431(
             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_431] = [__v_23, __v_27];
-            record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_434] = [__v_23, __v_27];
+            record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -39806,23 +39249,23 @@ fn aiur_fn_431(
         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_431] = [__v_11, __v_15];
-        record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_434] = [__v_11, __v_15];
+        record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_432: usize = 5;
-const IN_432: usize = 5;
-const OUT_432: usize = 1;
-fn aiur_fn_432(
-  inp: [G; IN_432],
+const INPUT_SIZE_435: usize = 5;
+const IN_435: usize = 5;
+const OUT_435: usize = 1;
+fn aiur_fn_435(
+  inp: [G; IN_435],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_432], ExecError> {
+) -> Result<[G; OUT_435], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -39832,8 +39275,8 @@ fn aiur_fn_432(
     let __v_5: G = (__v_3 - __v_4);
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_432] = [__v_0];
-        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_0];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -39844,25 +39287,25 @@ fn aiur_fn_432(
         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_432] = { let __args: [G; IN_432] = [__v_10, __v_1, __v_2, __v_3, __v_12]; 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 __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_10, __v_1, __v_2, __v_3, __v_12]; 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_13: G = __r_arr[0];
-        let __ret: [G; OUT_432] = [__v_13];
-        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_13];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_433: usize = 6;
-const IN_433: usize = 6;
-const OUT_433: usize = 2;
-fn aiur_fn_433(
-  inp: [G; IN_433],
+const INPUT_SIZE_436: usize = 6;
+const IN_436: usize = 6;
+const OUT_436: usize = 2;
+fn aiur_fn_436(
+  inp: [G; IN_436],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_433], ExecError> {
+) -> Result<[G; OUT_436], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -39883,14 +39326,14 @@ fn aiur_fn_433(
         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_433] = [__v_11, __v_15];
-        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_436] = [__v_11, __v_15];
+        record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __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];
@@ -39906,7 +39349,7 @@ fn aiur_fn_433(
             let __v_22: G = __loaded[10];
             match __v_12.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_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];
@@ -39922,7 +39365,7 @@ fn aiur_fn_433(
                 let __v_34: G = __loaded[10];
                 match __v_24.as_canonical_u64() {
                   5u64 => {
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_29]; 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_35: G = __r_arr[0];
                     match __v_35.as_canonical_u64() {
                       0u64 => {
@@ -39931,19 +39374,19 @@ fn aiur_fn_433(
                         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_433] = [__v_36, __v_40];
-                        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_436] = [__v_36, __v_40];
+                        record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_36: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_29, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_29, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                         let __v_37: G = __r_arr[0];
-                        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_3, __v_4, __v_5]; 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_38: G = __r_arr[0];
-                        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_38, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_38, __v_3, __v_4, __v_5]; 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_39: G = __r_arr[0];
-                        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_39]; 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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_39]; 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_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 };
@@ -39959,19 +39402,19 @@ fn aiur_fn_433(
                                 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_781] = { let __args: [G; IN_781] = [__v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[784].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_784] = unsafe { *(result.output.as_ptr() as *const [G; OUT_784]) }; __ret } else { aiur_fn_784(__args, record, io_buffer, __cu)? } };
                                 let __v_50: G = __r_arr[0];
-                                let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_49, __v_50]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_49, __v_50]; 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_51: G = __r_arr[0];
-                                let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_51, __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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_51, __v_3, __v_4, __v_5]; 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_52: G = __r_arr[0];
-                                let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_39, __v_52, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_39, __v_52, __v_3, __v_4, __v_5]; 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_53: G = __r_arr[0];
                                 match __v_53.as_canonical_u64() {
                                   1u64 => {
                                     let __v_54: G = G::from_u64(1);
-                                    let __ret: [G; OUT_433] = [__v_54, __v_51];
-                                    record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_436] = [__v_54, __v_51];
+                                    record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   0u64 => {
@@ -39980,8 +39423,8 @@ fn aiur_fn_433(
                                     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_433] = [__v_54, __v_58];
-                                    record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_436] = [__v_54, __v_58];
+                                    record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -39995,8 +39438,8 @@ fn aiur_fn_433(
                                 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_433] = [__v_47, __v_51];
-                                record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_436] = [__v_47, __v_51];
+                                record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -40007,8 +39450,8 @@ fn aiur_fn_433(
                             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_433] = [__v_46, __v_50];
-                            record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_436] = [__v_46, __v_50];
+                            record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -40034,15 +39477,15 @@ fn aiur_fn_433(
   })
 }
 
-const INPUT_SIZE_434: usize = 2;
-const IN_434: usize = 2;
-const OUT_434: usize = 1;
-fn aiur_fn_434(
-  inp: [G; IN_434],
+const INPUT_SIZE_437: usize = 2;
+const IN_437: usize = 2;
+const OUT_437: usize = 1;
+fn aiur_fn_437(
+  inp: [G; IN_437],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_434], ExecError> {
+) -> Result<[G; OUT_437], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40056,24 +39499,24 @@ fn aiur_fn_434(
         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));
+        let __ret: [G; OUT_437] = [__v_8];
+        record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_434] = [__v_3];
-            record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_437] = [__v_3];
+            record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_4, __v_6]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_434] = [__v_7];
-            record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_437] = [__v_7];
+            record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -40085,15 +39528,15 @@ fn aiur_fn_434(
   })
 }
 
-const INPUT_SIZE_435: usize = 1;
-const IN_435: usize = 1;
-const OUT_435: usize = 2;
-fn aiur_fn_435(
-  inp: [G; IN_435],
+const INPUT_SIZE_438: usize = 1;
+const IN_438: usize = 1;
+const OUT_438: usize = 2;
+fn aiur_fn_438(
+  inp: [G; IN_438],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_435], ExecError> {
+) -> Result<[G; OUT_438], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -40104,8 +39547,8 @@ fn aiur_fn_435(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_435] = [__v_5, __v_2];
-        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_438] = [__v_5, __v_2];
+        record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -40113,23 +39556,23 @@ fn aiur_fn_435(
         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_435] = [__v_5, __v_8];
-        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_438] = [__v_5, __v_8];
+        record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_436: usize = 1;
-const IN_436: usize = 1;
-const OUT_436: usize = 3;
-fn aiur_fn_436(
-  inp: [G; IN_436],
+const INPUT_SIZE_439: usize = 1;
+const IN_439: usize = 1;
+const OUT_439: usize = 3;
+fn aiur_fn_439(
+  inp: [G; IN_439],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_436], ExecError> {
+) -> Result<[G; OUT_439], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -40140,8 +39583,8 @@ fn aiur_fn_436(
     match __v_1.as_canonical_u64() {
       5u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_436] = [__v_5, __v_2, __v_3];
-        record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_439] = [__v_5, __v_2, __v_3];
+        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -40154,23 +39597,23 @@ fn aiur_fn_436(
         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_436] = [__v_5, __v_9, __v_13];
-        record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_439] = [__v_5, __v_9, __v_13];
+        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_437: usize = 2;
-const IN_437: usize = 2;
-const OUT_437: usize = 1;
-fn aiur_fn_437(
-  inp: [G; IN_437],
+const INPUT_SIZE_440: usize = 2;
+const IN_440: usize = 2;
+const OUT_440: usize = 1;
+fn aiur_fn_440(
+  inp: [G; IN_440],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_437], ExecError> {
+) -> Result<[G; OUT_440], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40184,8 +39627,8 @@ fn aiur_fn_437(
         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_437] = [__v_8];
-        record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_440] = [__v_8];
+        record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -40193,23 +39636,23 @@ fn aiur_fn_437(
           0u64 => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = G::from_u64(0);
-            let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_3, __v_5, __v_6]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_3, __v_5, __v_6]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_437] = [__v_7];
-            record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_440] = [__v_7];
+            record.function_queries[440].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_437] = { let __args: [G; IN_437] = [__v_4, __v_6]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6]; 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 __v_8: G = G::from_u64(1);
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_7, __v_8, __v_9]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_7, __v_8, __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));
+            let __ret: [G; OUT_440] = [__v_10];
+            record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -40221,41 +39664,41 @@ fn aiur_fn_437(
   })
 }
 
-const INPUT_SIZE_438: usize = 4;
-const IN_438: usize = 4;
-const OUT_438: usize = 1;
-fn aiur_fn_438(
-  inp: [G; IN_438],
+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_438], ExecError> {
+) -> Result<[G; OUT_441], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0]; 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_5, __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 __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_5, __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_6: G = __r_arr[0];
-    let __ret: [G; OUT_438] = [__v_6];
-    record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_441] = [__v_6];
+    record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_439: usize = 4;
-const IN_439: usize = 4;
-const OUT_439: usize = 1;
-fn aiur_fn_439(
-  inp: [G; IN_439],
+const INPUT_SIZE_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_439], ExecError> {
+) -> Result<[G; OUT_442], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40268,10 +39711,10 @@ fn aiur_fn_439(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_1, __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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_5]; 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 __ret: [G; OUT_439] = [__v_8];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_442] = [__v_8];
+        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -40279,16 +39722,16 @@ fn aiur_fn_439(
         let __v_9: G = G::from_u64(1);
         let __v_10: G = G::from_u64(0);
         let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_11]; 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_11]; 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_12: G = __r_arr[0];
         let __v_13: G = G::from_u64(0);
         let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_439] = [__v_14];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_442] = [__v_14];
+        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __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];
@@ -40302,93 +39745,93 @@ fn aiur_fn_439(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__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[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 __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__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[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 __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
+        let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__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[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_22: 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_446] = { let __args: [G; IN_446] = [__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[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_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_22, __v_6]; 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_22, __v_6]; 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_23: G = __r_arr[0];
-        let __ret: [G; OUT_439] = [__v_23];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_442] = [__v_23];
+        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_8, __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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_8, __v_1, __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_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_440] = { let __args: [G; IN_440] = [__v_10, __v_9, __v_13, __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 __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_10, __v_9, __v_13, __v_1, __v_2, __v_3]; 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_14: G = __r_arr[0];
-        let __ret: [G; OUT_439] = [__v_14];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_442] = [__v_14];
+        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_5, __v_1, __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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_5, __v_1, __v_2, __v_3]; 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_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(0);
         let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_6, __v_10, __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_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_439] = [__v_14];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_442] = [__v_14];
+        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_5, __v_1, __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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_5, __v_1, __v_2, __v_3]; 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_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_441] = { let __args: [G; IN_441] = [__v_6, __v_10, __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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_6, __v_10, __v_2, __v_3]; 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_8, __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_8, __v_11]; 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_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
         let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_439] = [__v_15];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_442] = [__v_15];
+        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_5, __v_1, __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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_5, __v_1, __v_2, __v_3]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_6, __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 __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_6, __v_5, __v_1, __v_2, __v_3]; 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_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_7, __v_6, __v_9]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_7, __v_6, __v_9]; 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_10, __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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_10, __v_1, __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_11: G = __r_arr[0];
-        let __ret: [G; OUT_439] = [__v_11];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_442] = [__v_11];
+        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__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 __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_3]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_439] = [__v_8];
-            record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_442] = [__v_8];
+            record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_3]; 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 __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_439] = [__v_8];
-            record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_442] = [__v_8];
+            record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -40397,11 +39840,11 @@ fn aiur_fn_439(
         }
       },
       8u64 => {
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_7, __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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_7, __v_1, __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_8, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_8, __v_1, __v_2, __v_3]; 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_9: G = __r_arr[0];
-        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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __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 };
@@ -40411,10 +39854,7 @@ fn aiur_fn_439(
         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_767] = { let __args: [G; IN_767] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
             let __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];
@@ -40428,49 +39868,52 @@ fn aiur_fn_439(
             let __v_25: G = __loaded[8];
             let __v_26: G = __loaded[9];
             let __v_27: G = __loaded[10];
+            if (__v_13 != __v_5) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
+            }
             match __v_17.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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_452] = { let __args: [G; IN_452] = [__v_19, __v_14, __v_30, __v_1, __v_2, __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_28: G = (__v_20 + __v_21);
+                let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_19, __v_14, __v_28, __v_1, __v_2, __v_3]; 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_29: G = __r_arr[0];
+                let __v_30: G = G::from_u64(0);
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_22, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_31: G = __r_arr[0];
-                let __v_32: G = G::from_u64(0);
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
-                let __v_33: G = __r_arr[0];
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
-                let __v_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() {
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+                let __v_32: 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_32.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_33: G = __loaded[0];
+                let __v_34: G = __loaded[1];
+                let __v_35: G = __loaded[2];
+                let __v_36: G = __loaded[3];
+                let __v_37: G = __loaded[4];
+                let __v_38: G = __loaded[5];
+                let __v_39: G = __loaded[6];
+                let __v_40: G = __loaded[7];
+                let __v_41: G = __loaded[8];
+                let __v_42: G = __loaded[9];
+                let __v_43: G = __loaded[10];
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+                let __v_44: G = __r_arr[0];
+                let __v_45: G = G::from_u64(1);
+                if (__v_44 != __v_45) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64() });
+                }
+                match __v_33.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_37, __v_14]; 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_35, __v_14]; 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_46: G = __r_arr[0];
-                    let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_46, __v_11, __v_20]; 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 __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_46, __v_11, __v_20]; 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_47: G = __r_arr[0];
                     let __v_48: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__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[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 __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_47, __v_6, __v_48, __v_5, __v_7, __v_29, __v_1, __v_2, __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_49: G = __r_arr[0];
-                    let __ret: [G; OUT_439] = [__v_49];
-                    record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_442] = [__v_49];
+                    record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_33.as_canonical_u64()));
                   },
                 }
               },
@@ -40491,15 +39934,15 @@ fn aiur_fn_439(
   })
 }
 
-const INPUT_SIZE_440: usize = 6;
-const IN_440: usize = 6;
-const OUT_440: usize = 1;
-fn aiur_fn_440(
-  inp: [G; IN_440],
+const INPUT_SIZE_443: usize = 6;
+const IN_443: usize = 6;
+const OUT_443: usize = 1;
+fn aiur_fn_443(
+  inp: [G; IN_443],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_440], ExecError> {
+) -> Result<[G; OUT_443], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40514,10 +39957,10 @@ fn aiur_fn_440(
     match __v_6.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_2, __v_9]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0, __v_2, __v_9]; 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_440] = [__v_10];
-        record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_443] = [__v_10];
+        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -40529,41 +39972,41 @@ fn aiur_fn_440(
         match __v_9.as_canonical_u64() {
           5u64 => {
             let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_10, __v_2, __v_13]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_10, __v_2, __v_13]; 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 __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_7, __v_14, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_7, __v_14, __v_3, __v_4, __v_5]; 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_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_440] = { let __args: [G; IN_440] = [__v_11, __v_8, __v_16, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_11, __v_8, __v_16, __v_3, __v_4, __v_5]; 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_17: G = __r_arr[0];
-            let __ret: [G; OUT_440] = [__v_17];
-            record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_443] = [__v_17];
+            record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_2, __v_13]; 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 __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0, __v_2, __v_13]; 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 __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_14, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_14, __v_3, __v_4, __v_5]; 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_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_15]; 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 __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_15]; 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_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_442] = { let __args: [G; IN_442] = [__v_7, __v_17, __v_3, __v_4, __v_5]; 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_20: G = G::from_u64(0);
+            let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_7, __v_17, __v_3, __v_4, __v_5]; 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_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 = 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_440] = { let __args: [G; IN_440] = [__v_18, __v_8, __v_24, __v_3, __v_4, __v_5]; 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_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 = { let __values: [G; 3] = [__v_19, __v_7, __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 = G::from_u64(1);
+            if (__v_16 != __v_24) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_24.as_canonical_u64() });
+            }
+            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_18, __v_8, __v_23, __v_3, __v_4, __v_5]; 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_25: G = __r_arr[0];
-            let __ret: [G; OUT_440] = [__v_25];
-            record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_443] = [__v_25];
+            record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -40575,21 +40018,21 @@ fn aiur_fn_440(
   })
 }
 
-const INPUT_SIZE_441: usize = 4;
-const IN_441: usize = 4;
-const OUT_441: usize = 1;
-fn aiur_fn_441(
-  inp: [G; IN_441],
+const INPUT_SIZE_444: usize = 4;
+const IN_444: usize = 4;
+const OUT_444: usize = 1;
+fn aiur_fn_444(
+  inp: [G; IN_444],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_441], ExecError> {
+) -> Result<[G; OUT_444], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_1, __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_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];
@@ -40598,92 +40041,92 @@ fn aiur_fn_441(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_441] = [__v_6];
-        record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_444] = [__v_6];
+        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_1, __v_2, __v_3]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__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 __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9]; 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_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_441] = [__v_11];
-        record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_444] = [__v_11];
+        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_442: usize = 5;
-const IN_442: usize = 5;
-const OUT_442: usize = 0;
-fn aiur_fn_442(
-  inp: [G; IN_442],
+const INPUT_SIZE_445: usize = 5;
+const IN_445: usize = 5;
+const OUT_445: usize = 0;
+fn aiur_fn_445(
+  inp: [G; IN_445],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_442], ExecError> {
+) -> Result<[G; OUT_445], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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_438] = { let __args: [G; IN_438] = [__v_0, __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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_5, __v_1, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_5, __v_1, __v_2, __v_3, __v_4]; 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_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_442] = [];
-    record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_445] = [];
+    record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_443: usize = 4;
-const IN_443: usize = 4;
-const OUT_443: usize = 1;
-fn aiur_fn_443(
-  inp: [G; IN_443],
+const INPUT_SIZE_446: usize = 4;
+const IN_446: usize = 4;
+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_443], ExecError> {
+) -> Result<[G; OUT_446], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0]; 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __v_5, __v_2, __v_3]; 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 __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_5, __v_2, __v_3]; 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_6: G = __r_arr[0];
-    let __ret: [G; OUT_443] = [__v_6];
-    record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_446] = [__v_6];
+    record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_444: usize = 4;
-const IN_444: usize = 4;
-const OUT_444: usize = 1;
-fn aiur_fn_444(
-  inp: [G; IN_444],
+const INPUT_SIZE_447: usize = 4;
+const IN_447: usize = 4;
+const OUT_447: usize = 1;
+fn aiur_fn_447(
+  inp: [G; IN_447],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_444], ExecError> {
+) -> Result<[G; OUT_447], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40696,10 +40139,10 @@ fn aiur_fn_444(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_1, __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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_5]; 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 __ret: [G; OUT_444] = [__v_8];
-        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_447] = [__v_8];
+        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -40707,16 +40150,16 @@ fn aiur_fn_444(
         let __v_9: G = G::from_u64(1);
         let __v_10: G = G::from_u64(0);
         let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_11]; 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_11]; 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_12: G = __r_arr[0];
         let __v_13: G = G::from_u64(0);
         let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_444] = [__v_14];
-        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_447] = [__v_14];
+        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __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];
@@ -40730,23 +40173,23 @@ fn aiur_fn_444(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__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[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 __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__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[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 __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
+        let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__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[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_22: 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_446] = { let __args: [G; IN_446] = [__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[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_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_22, __v_6]; 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_22, __v_6]; 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_23: G = __r_arr[0];
-        let __ret: [G; OUT_444] = [__v_23];
-        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_447] = [__v_23];
+        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_5, __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_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];
@@ -40756,16 +40199,16 @@ fn aiur_fn_444(
         match __v_9.as_canonical_u64() {
           5u64 => {
             let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_11, __v_6, __v_13]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_11, __v_6, __v_13]; 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_14: G = __r_arr[0];
-            let __ret: [G; OUT_444] = [__v_14];
-            record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_447] = [__v_14];
+            record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_8, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_8, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_13]; 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 __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __v_16: G = __r_arr[2];
@@ -40774,10 +40217,10 @@ fn aiur_fn_444(
               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_399] = { let __args: [G; IN_399] = [__v_16, __v_6, __v_18]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_16, __v_6, __v_18]; 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_19: G = __r_arr[0];
-            let __ret: [G; OUT_444] = [__v_19];
-            record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_447] = [__v_19];
+            record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -40785,55 +40228,55 @@ fn aiur_fn_444(
       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_443] = { let __args: [G; IN_443] = [__v_6, __v_9, __v_2, __v_3]; 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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_6, __v_9, __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_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_444] = [__v_13];
-        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_447] = [__v_13];
+        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_5, __v_1, __v_2, __v_3]; 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_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_445] = { let __args: [G; IN_445] = [__v_6, __v_10, __v_2, __v_3]; 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 __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_6, __v_10, __v_2, __v_3]; 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_8, __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_8, __v_11]; 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_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
         let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_444] = [__v_15];
-        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_447] = [__v_15];
+        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_7, __v_6, __v_8]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_7, __v_6, __v_8]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_9, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_9, __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_10: G = __r_arr[0];
-        let __ret: [G; OUT_444] = [__v_10];
-        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_447] = [__v_10];
+        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__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 __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_3]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_444] = [__v_8];
-            record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_447] = [__v_8];
+            record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_3]; 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 __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_444] = [__v_8];
-            record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_447] = [__v_8];
+            record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -40842,11 +40285,11 @@ fn aiur_fn_444(
         }
       },
       8u64 => {
-        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_7, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_7, __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_8, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_8, __v_1, __v_2, __v_3]; 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_9: G = __r_arr[0];
-        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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __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 };
@@ -40856,10 +40299,7 @@ fn aiur_fn_444(
         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_767] = { let __args: [G; IN_767] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
             let __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];
@@ -40873,49 +40313,52 @@ fn aiur_fn_444(
             let __v_25: G = __loaded[8];
             let __v_26: G = __loaded[9];
             let __v_27: G = __loaded[10];
+            if (__v_13 != __v_5) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
+            }
             match __v_17.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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_452] = { let __args: [G; IN_452] = [__v_19, __v_14, __v_30, __v_1, __v_2, __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_28: G = (__v_20 + __v_21);
+                let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_19, __v_14, __v_28, __v_1, __v_2, __v_3]; 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_29: G = __r_arr[0];
+                let __v_30: G = G::from_u64(0);
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_22, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_31: G = __r_arr[0];
-                let __v_32: G = G::from_u64(0);
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
-                let __v_33: G = __r_arr[0];
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
-                let __v_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() {
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+                let __v_32: 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_32.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_33: G = __loaded[0];
+                let __v_34: G = __loaded[1];
+                let __v_35: G = __loaded[2];
+                let __v_36: G = __loaded[3];
+                let __v_37: G = __loaded[4];
+                let __v_38: G = __loaded[5];
+                let __v_39: G = __loaded[6];
+                let __v_40: G = __loaded[7];
+                let __v_41: G = __loaded[8];
+                let __v_42: G = __loaded[9];
+                let __v_43: G = __loaded[10];
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+                let __v_44: G = __r_arr[0];
+                let __v_45: G = G::from_u64(1);
+                if (__v_44 != __v_45) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64() });
+                }
+                match __v_33.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_37, __v_14]; 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_35, __v_14]; 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_46: G = __r_arr[0];
-                    let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_46, __v_11, __v_20]; 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 __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_46, __v_11, __v_20]; 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_47: G = __r_arr[0];
                     let __v_48: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__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[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 __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_47, __v_6, __v_48, __v_5, __v_7, __v_29, __v_1, __v_2, __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_49: G = __r_arr[0];
-                    let __ret: [G; OUT_444] = [__v_49];
-                    record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_447] = [__v_49];
+                    record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_33.as_canonical_u64()));
                   },
                 }
               },
@@ -40936,21 +40379,21 @@ fn aiur_fn_444(
   })
 }
 
-const INPUT_SIZE_445: usize = 4;
-const IN_445: usize = 4;
-const OUT_445: usize = 1;
-fn aiur_fn_445(
-  inp: [G; IN_445],
+const INPUT_SIZE_448: usize = 4;
+const IN_448: usize = 4;
+const OUT_448: usize = 1;
+fn aiur_fn_448(
+  inp: [G; IN_448],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_445], ExecError> {
+) -> Result<[G; OUT_448], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __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_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];
@@ -40959,37 +40402,37 @@ fn aiur_fn_445(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_445] = [__v_6];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_448] = [__v_6];
+        record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_1, __v_2, __v_3]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__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 __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9]; 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_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_445] = [__v_11];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_448] = [__v_11];
+        record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_446: usize = 11;
-const IN_446: usize = 11;
-const OUT_446: usize = 1;
-fn aiur_fn_446(
-  inp: [G; IN_446],
+const INPUT_SIZE_449: usize = 11;
+const IN_449: usize = 11;
+const OUT_449: usize = 1;
+fn aiur_fn_449(
+  inp: [G; IN_449],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_446], ExecError> {
+) -> Result<[G; OUT_449], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41004,43 +40447,43 @@ fn aiur_fn_446(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_446] = [__v_2];
-        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_2];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __ret: [G; OUT_446] = [__v_2];
-        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_2];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __ret: [G; OUT_446] = [__v_2];
-        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_2];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_446] = [__v_2];
-        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_2];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_446] = [__v_2];
-        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_2];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_446] = [__v_2];
-        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_2];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_446] = [__v_2];
-        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_2];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_446] = [__v_2];
-        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_2];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -41050,15 +40493,15 @@ fn aiur_fn_446(
   })
 }
 
-const INPUT_SIZE_447: usize = 11;
-const IN_447: usize = 11;
-const OUT_447: usize = 1;
-fn aiur_fn_447(
-  inp: [G; IN_447],
+const INPUT_SIZE_450: usize = 11;
+const IN_450: usize = 11;
+const OUT_450: usize = 1;
+fn aiur_fn_450(
+  inp: [G; IN_450],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_447], ExecError> {
+) -> Result<[G; OUT_450], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41073,43 +40516,43 @@ fn aiur_fn_447(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_447] = [__v_1];
-        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_450] = [__v_1];
+        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __ret: [G; OUT_447] = [__v_1];
-        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_450] = [__v_1];
+        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __ret: [G; OUT_447] = [__v_1];
-        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_450] = [__v_1];
+        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_447] = [__v_1];
-        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_450] = [__v_1];
+        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_447] = [__v_1];
-        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_450] = [__v_1];
+        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_447] = [__v_1];
-        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_450] = [__v_1];
+        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_447] = [__v_1];
-        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_450] = [__v_1];
+        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_447] = [__v_1];
-        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_450] = [__v_1];
+        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -41119,23 +40562,23 @@ fn aiur_fn_447(
   })
 }
 
-const INPUT_SIZE_448: usize = 3;
-const IN_448: usize = 3;
-const OUT_448: usize = 1;
-fn aiur_fn_448(
-  inp: [G; IN_448],
+const INPUT_SIZE_451: usize = 3;
+const IN_451: usize = 3;
+const OUT_451: usize = 1;
+fn aiur_fn_451(
+  inp: [G; IN_451],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_448], ExecError> {
+) -> Result<[G; OUT_451], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_448] = [__v_0];
-        record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_451] = [__v_0];
+        record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -41153,14 +40596,14 @@ fn aiur_fn_448(
             match __v_7.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_5, __v_8, __v_10]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_8, __v_10]; 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_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_448] = { let __args: [G; IN_448] = [__v_11, __v_9, __v_13]; 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 __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_11, __v_9, __v_13]; 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_14: G = __r_arr[0];
-                let __ret: [G; OUT_448] = [__v_14];
-                record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_451] = [__v_14];
+                record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -41177,15 +40620,15 @@ fn aiur_fn_448(
   })
 }
 
-const INPUT_SIZE_449: usize = 9;
-const IN_449: usize = 9;
-const OUT_449: usize = 1;
-fn aiur_fn_449(
-  inp: [G; IN_449],
+const INPUT_SIZE_452: usize = 9;
+const IN_452: usize = 9;
+const OUT_452: usize = 1;
+fn aiur_fn_452(
+  inp: [G; IN_452],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_449], ExecError> {
+) -> Result<[G; OUT_452], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41206,24 +40649,24 @@ fn aiur_fn_449(
         let __v_13: G = (__v_1 - __v_2);
         match __v_13.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_5, __v_10, __v_6, __v_7, __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 __ret: [G; OUT_449] = [__v_10];
-            record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_5, __v_10, __v_6, __v_7, __v_8]; 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 __ret: [G; OUT_452] = [__v_10];
+            record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_5, __v_10, __v_11, __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 __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_5, __v_10, __v_11, __v_6, __v_7, __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_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_399] = { let __args: [G; IN_399] = [__v_11, __v_15, __v_16]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_11, __v_15, __v_16]; 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_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_449] = { let __args: [G; IN_449] = [__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[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 __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__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[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_20: G = __r_arr[0];
-            let __ret: [G; OUT_449] = [__v_20];
-            record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_452] = [__v_20];
+            record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41235,15 +40678,15 @@ fn aiur_fn_449(
   })
 }
 
-const INPUT_SIZE_450: usize = 6;
-const IN_450: usize = 6;
-const OUT_450: usize = 0;
-fn aiur_fn_450(
-  inp: [G; IN_450],
+const INPUT_SIZE_453: usize = 6;
+const IN_453: usize = 6;
+const OUT_453: usize = 0;
+fn aiur_fn_453(
+  inp: [G; IN_453],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_450], ExecError> {
+) -> Result<[G; OUT_453], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41253,33 +40696,33 @@ fn aiur_fn_450(
     let __v_5: G = inp[5];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_450] = [];
-        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_453] = [];
+        record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_1, __v_3, __v_4, __v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         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_225] = { let __args: [G; IN_225] = [__v_6, __v_9]; 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_6, __v_9]; 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_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_450] = [];
-            record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_453] = [];
+            record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_2]; 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_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 __ret: [G; OUT_450] = [];
-            record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_453] = [];
+            record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41288,15 +40731,15 @@ fn aiur_fn_450(
   })
 }
 
-const INPUT_SIZE_451: usize = 5;
-const IN_451: usize = 5;
-const OUT_451: usize = 1;
-fn aiur_fn_451(
-  inp: [G; IN_451],
+const INPUT_SIZE_454: usize = 5;
+const IN_454: usize = 5;
+const OUT_454: usize = 1;
+fn aiur_fn_454(
+  inp: [G; IN_454],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_451], ExecError> {
+) -> Result<[G; OUT_454], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41305,14 +40748,14 @@ fn aiur_fn_451(
     let __v_4: G = inp[4];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_451] = [__v_5];
-        record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_454] = [__v_5];
+        record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_2, __v_3, __v_4]; 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_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];
@@ -41323,15 +40766,15 @@ fn aiur_fn_451(
           5u64 => {
             let __v_10: G = G::from_u64(1);
             let __v_11: G = (__v_1 - __v_10);
-            let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_8, __v_11, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_8, __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_12: G = __r_arr[0];
-            let __ret: [G; OUT_451] = [__v_12];
-            record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_454] = [__v_12];
+            record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_451] = [__v_5];
-            record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_454] = [__v_5];
+            record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41340,15 +40783,15 @@ fn aiur_fn_451(
   })
 }
 
-const INPUT_SIZE_452: usize = 6;
-const IN_452: usize = 6;
-const OUT_452: usize = 1;
-fn aiur_fn_452(
-  inp: [G; IN_452],
+const INPUT_SIZE_455: usize = 6;
+const IN_455: usize = 6;
+const OUT_455: usize = 1;
+fn aiur_fn_455(
+  inp: [G; IN_455],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_452], ExecError> {
+) -> Result<[G; OUT_455], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41356,9 +40799,9 @@ fn aiur_fn_452(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0, __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 __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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_6, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_2, __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_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];
@@ -41370,31 +40813,31 @@ fn aiur_fn_452(
         let __v_12: G = G::from_u64(0);
         let __v_13: G = G::from_u64(0);
         let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_9, __v_14]; 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_9, __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 __ret: [G; OUT_452] = [__v_15];
-        record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_455] = [__v_15];
+        record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_452] = [__v_12];
-        record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_455] = [__v_12];
+        record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_453: usize = 5;
-const IN_453: usize = 5;
-const OUT_453: usize = 0;
-fn aiur_fn_453(
-  inp: [G; IN_453],
+const INPUT_SIZE_456: usize = 5;
+const IN_456: usize = 5;
+const OUT_456: usize = 0;
+fn aiur_fn_456(
+  inp: [G; IN_456],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_453], ExecError> {
+) -> Result<[G; OUT_456], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41403,45 +40846,45 @@ fn aiur_fn_453(
     let __v_4: G = inp[4];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_453] = [];
-        record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_456] = [];
+        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_1, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[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 __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_5, __v_8]; 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_8]; 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_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_453] = [];
-        record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_456] = [];
+        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_454: usize = 1;
-const IN_454: usize = 1;
-const OUT_454: usize = 1;
-fn aiur_fn_454(
-  inp: [G; IN_454],
+const INPUT_SIZE_457: usize = 1;
+const IN_457: usize = 1;
+const OUT_457: usize = 1;
+fn aiur_fn_457(
+  inp: [G; IN_457],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_454], ExecError> {
+) -> Result<[G; OUT_457], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 __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_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_1, __v_0, __v_2]; 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 __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_1, __v_0, __v_2]; 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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(2);
     let __v_5: G = G::from_u64(1);
@@ -41449,27 +40892,27 @@ fn aiur_fn_454(
     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_454] = [__v_9];
-    record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_457] = [__v_9];
+    record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_455: usize = 1;
-const IN_455: usize = 1;
-const OUT_455: usize = 1;
-fn aiur_fn_455(
-  inp: [G; IN_455],
+const INPUT_SIZE_458: usize = 1;
+const IN_458: usize = 1;
+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_455], ExecError> {
+) -> Result<[G; OUT_458], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+    let __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_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_1, __v_0, __v_2]; 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 __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_1, __v_0, __v_2]; 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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(2);
     let __v_5: G = G::from_u64(1);
@@ -41477,21 +40920,21 @@ fn aiur_fn_455(
     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_455] = [__v_9];
-    record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_458] = [__v_9];
+    record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_456: usize = 3;
-const IN_456: usize = 3;
-const OUT_456: usize = 1;
-fn aiur_fn_456(
-  inp: [G; IN_456],
+const INPUT_SIZE_459: usize = 3;
+const IN_459: usize = 3;
+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_456], ExecError> {
+) -> Result<[G; OUT_459], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41502,21 +40945,21 @@ fn aiur_fn_456(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_4]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_456] = [__v_2];
-            record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_459] = [__v_2];
+            record.function_queries[459].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_456] = { let __args: [G; IN_456] = [__v_0, __v_5, __v_8]; 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 __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_5, __v_8]; 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_9: G = __r_arr[0];
-            let __ret: [G; OUT_456] = [__v_9];
-            record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_459] = [__v_9];
+            record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -41531,15 +40974,15 @@ fn aiur_fn_456(
   })
 }
 
-const INPUT_SIZE_457: usize = 5;
-const IN_457: usize = 5;
-const OUT_457: usize = 1;
-fn aiur_fn_457(
-  inp: [G; IN_457],
+const INPUT_SIZE_460: usize = 5;
+const IN_460: usize = 5;
+const OUT_460: usize = 1;
+fn aiur_fn_460(
+  inp: [G; IN_460],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_457], ExecError> {
+) -> Result<[G; OUT_460], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41550,175 +40993,175 @@ fn aiur_fn_457(
     match __v_5.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_457] = [__v_6];
-        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_460] = [__v_6];
+        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_1]; 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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_1]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_6, __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 __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6, __v_7]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_2, __v_8]; 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 __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_2, __v_8]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_0, __v_1, __v_9, __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 __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_0, __v_1, __v_9, __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_10: G = __r_arr[0];
-        let __ret: [G; OUT_457] = [__v_10];
-        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_460] = [__v_10];
+        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_458: usize = 5;
-const IN_458: usize = 5;
-const OUT_458: usize = 1;
-fn aiur_fn_458(
-  inp: [G; IN_458],
+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_458], ExecError> {
+) -> Result<[G; OUT_461], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_1, __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_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_458] = [__v_6];
-        record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3, __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 __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_458] = [__v_7];
-            record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_461] = [__v_7];
+            record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__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 __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_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __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 __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_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_458] = [__v_10];
-                record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_461] = [__v_10];
+                record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_7, __v_8, __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 __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_7, __v_8, __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_10: G = __r_arr[0];
                 match __v_10.as_canonical_u64() {
                   1u64 => {
                     let __v_11: G = G::from_u64(1);
-                    let __ret: [G; OUT_458] = [__v_11];
-                    record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_461] = [__v_11];
+                    record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_7, __v_8, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_7, __v_8, __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_11: G = __r_arr[0];
                     match __v_11.as_canonical_u64() {
                       1u64 => {
                         let __v_12: G = G::from_u64(1);
-                        let __ret: [G; OUT_458] = [__v_12];
-                        record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_461] = [__v_12];
+                        record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0];
-                        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_1, __v_2, __v_3, __v_4]; 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_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_458] = [__v_15];
-                            record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_461] = [__v_15];
+                            record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_12, __v_13, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_12, __v_13, __v_2, __v_3, __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_15: G = __r_arr[0];
                             match __v_15.as_canonical_u64() {
                               1u64 => {
                                 let __v_16: G = G::from_u64(1);
-                                let __ret: [G; OUT_458] = [__v_16];
-                                record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_461] = [__v_16];
+                                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_12, __v_13, __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 __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_16: G = __r_arr[0];
                                 match __v_16.as_canonical_u64() {
                                   1u64 => {
                                     let __v_17: G = G::from_u64(1);
-                                    let __ret: [G; OUT_458] = [__v_17];
-                                    record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_461] = [__v_17];
+                                    record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   0u64 => {
-                                    let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_12, __v_13, __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 __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_12, __v_13, __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_17: G = __r_arr[0];
                                     match __v_17.as_canonical_u64() {
                                       1u64 => {
                                         let __v_18: G = G::from_u64(1);
-                                        let __ret: [G; OUT_458] = [__v_18];
-                                        record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_461] = [__v_18];
+                                        record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       0u64 => {
-                                        let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_13, __v_12, __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 __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_13, __v_12, __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_18: G = __r_arr[0];
                                         match __v_18.as_canonical_u64() {
                                           1u64 => {
                                             let __v_19: G = G::from_u64(1);
-                                            let __ret: [G; OUT_458] = [__v_19];
-                                            record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_461] = [__v_19];
+                                            record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           0u64 => {
-                                            let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_12, __v_13, __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_19: G = __r_arr[0];
                                             let __v_20: G = __r_arr[1];
                                             match __v_19.as_canonical_u64() {
                                               1u64 => {
-                                                let __ret: [G; OUT_458] = [__v_20];
-                                                record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_461] = [__v_20];
+                                                record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               0u64 => {
                                                 let __v_21: G = G::from_u64(16);
-                                                let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_12, __v_13, __v_21, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_12, __v_13, __v_21, __v_2, __v_3, __v_4]; 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_22: G = __r_arr[0];
                                                 let __v_23: G = __r_arr[1];
                                                 match __v_22.as_canonical_u64() {
                                                   1u64 => {
-                                                    let __ret: [G; OUT_458] = [__v_23];
-                                                    record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_461] = [__v_23];
+                                                    record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                   0u64 => {
-                                                    let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_12, __v_13, __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 __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_12, __v_13, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0];
-                                                    let __ret: [G; OUT_458] = [__v_24];
-                                                    record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_461] = [__v_24];
+                                                    record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
@@ -41777,15 +41220,15 @@ fn aiur_fn_458(
   })
 }
 
-const INPUT_SIZE_459: usize = 5;
-const IN_459: usize = 5;
-const OUT_459: usize = 1;
-fn aiur_fn_459(
-  inp: [G; IN_459],
+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_459], ExecError> {
+) -> Result<[G; OUT_462], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41806,16 +41249,16 @@ fn aiur_fn_459(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_10]; 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_6, __v_10]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_459] = [__v_13];
-            record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_462] = [__v_13];
+            record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_459] = [__v_13];
-            record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_462] = [__v_13];
+            record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41828,22 +41271,22 @@ fn aiur_fn_459(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_6, __v_10, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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_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_457] = { let __args: [G; IN_457] = [__v_7, __v_11, __v_15, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_7, __v_11, __v_15, __v_3, __v_4]; 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_16: G = __r_arr[0];
-                let __ret: [G; OUT_459] = [__v_16];
-                record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_462] = [__v_16];
+                record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_459] = [__v_14];
-                record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_462] = [__v_14];
+                record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -41853,8 +41296,8 @@ fn aiur_fn_459(
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_459] = [__v_13];
-            record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_462] = [__v_13];
+            record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41867,22 +41310,22 @@ fn aiur_fn_459(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_6, __v_10, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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_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_457] = { let __args: [G; IN_457] = [__v_7, __v_11, __v_15, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_7, __v_11, __v_15, __v_3, __v_4]; 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_16: G = __r_arr[0];
-                let __ret: [G; OUT_459] = [__v_16];
-                record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_462] = [__v_16];
+                record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_459] = [__v_14];
-                record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_462] = [__v_14];
+                record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -41892,55 +41335,55 @@ fn aiur_fn_459(
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_459] = [__v_13];
-            record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_462] = [__v_13];
+            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_459] = [__v_9];
-        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_462] = [__v_9];
+        record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_460: usize = 5;
-const IN_460: usize = 5;
-const OUT_460: usize = 1;
-fn aiur_fn_460(
-  inp: [G; IN_460],
+const INPUT_SIZE_463: usize = 5;
+const IN_463: usize = 5;
+const OUT_463: usize = 1;
+fn aiur_fn_463(
+  inp: [G; IN_463],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_460], ExecError> {
+) -> Result<[G; OUT_463], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_5, __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 __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_5, __v_2, __v_3, __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_6: G = __r_arr[0];
     match __v_6.as_canonical_u64() {
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_460] = [__v_7];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_463] = [__v_7];
+        record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_1, __v_2, __v_3, __v_4]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_5, __v_7, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_5, __v_7, __v_2, __v_3, __v_4]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_460] = [__v_8];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_463] = [__v_8];
+        record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -41950,23 +41393,23 @@ fn aiur_fn_460(
   })
 }
 
-const INPUT_SIZE_461: usize = 4;
-const IN_461: usize = 4;
-const OUT_461: usize = 1;
-fn aiur_fn_461(
-  inp: [G; IN_461],
+const INPUT_SIZE_464: usize = 4;
+const IN_464: usize = 4;
+const OUT_464: usize = 1;
+fn aiur_fn_464(
+  inp: [G; IN_464],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_461], ExecError> {
+) -> Result<[G; OUT_464], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_1, __v_2, __v_3]; 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_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];
@@ -41982,63 +41425,63 @@ fn aiur_fn_461(
         match __v_10.as_canonical_u64() {
           0u64 => {
             let __v_13: G = G::from_u64(1);
-            let __ret: [G; OUT_461] = [__v_13];
-            record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_464] = [__v_13];
+            record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_461] = [__v_13];
-            record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_464] = [__v_13];
+            record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_461] = [__v_10];
-        record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_464] = [__v_10];
+        record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_462: usize = 5;
-const IN_462: usize = 5;
-const OUT_462: usize = 1;
-fn aiur_fn_462(
-  inp: [G; IN_462],
+const INPUT_SIZE_465: usize = 5;
+const IN_465: usize = 5;
+const OUT_465: usize = 1;
+fn aiur_fn_465(
+  inp: [G; IN_465],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_462], ExecError> {
+) -> Result<[G; OUT_465], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_5, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_5, __v_2, __v_3, __v_4]; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_6, __v_3]; 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 __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_6, __v_3]; 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_7: G = __r_arr[0];
     match __v_7.as_canonical_u64() {
       0u64 => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_462] = [__v_8];
-        record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_465] = [__v_8];
+        record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_1, __v_2, __v_3, __v_4]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_5, __v_8, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_5, __v_8, __v_2, __v_3, __v_4]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_462] = [__v_9];
-        record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_465] = [__v_9];
+        record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -42048,19 +41491,19 @@ fn aiur_fn_462(
   })
 }
 
-const INPUT_SIZE_463: usize = 2;
-const IN_463: usize = 2;
-const OUT_463: usize = 1;
-fn aiur_fn_463(
-  inp: [G; IN_463],
+const INPUT_SIZE_466: usize = 2;
+const IN_466: usize = 2;
+const OUT_466: usize = 1;
+fn aiur_fn_466(
+  inp: [G; IN_466],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_463], ExecError> {
+) -> Result<[G; OUT_466], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_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 };
@@ -42070,7 +41513,7 @@ fn aiur_fn_463(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __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];
@@ -42086,14 +41529,14 @@ fn aiur_fn_463(
         let __v_19: G = __loaded[10];
         match __v_9.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_14]; 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_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_767] = { let __args: [G; IN_767] = [__v_14, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_14, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_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];
@@ -42112,81 +41555,81 @@ fn aiur_fn_463(
                     match __v_30.as_canonical_u64() {
                       0u64 => {
                         let __v_35: G = G::from_u64(1);
-                        let __ret: [G; OUT_463] = [__v_35];
-                        record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_466] = [__v_35];
+                        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_35: G = G::from_u64(0);
-                        let __ret: [G; OUT_463] = [__v_35];
-                        record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_466] = [__v_35];
+                        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_35: G = G::from_u64(0);
-                    let __ret: [G; OUT_463] = [__v_35];
-                    record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_466] = [__v_35];
+                    record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_21: G = G::from_u64(0);
-                let __ret: [G; OUT_463] = [__v_21];
-                record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_466] = [__v_21];
+                record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_20: G = G::from_u64(0);
-            let __ret: [G; OUT_463] = [__v_20];
-            record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_466] = [__v_20];
+            record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_463] = [__v_8];
-        record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_466] = [__v_8];
+        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_464: usize = 5;
-const IN_464: usize = 5;
-const OUT_464: usize = 1;
-fn aiur_fn_464(
-  inp: [G; IN_464],
+const INPUT_SIZE_467: usize = 5;
+const IN_467: usize = 5;
+const OUT_467: usize = 1;
+fn aiur_fn_467(
+  inp: [G; IN_467],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_464], ExecError> {
+) -> Result<[G; OUT_467], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __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 __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __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_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_464] = [__v_6];
-        record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_467] = [__v_6];
+        record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_1, __v_0, __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 __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_1, __v_0, __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_6: G = __r_arr[0];
-        let __ret: [G; OUT_464] = [__v_6];
-        record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_467] = [__v_6];
+        record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -42196,15 +41639,15 @@ fn aiur_fn_464(
   })
 }
 
-const INPUT_SIZE_465: usize = 5;
-const IN_465: usize = 5;
-const OUT_465: usize = 1;
-fn aiur_fn_465(
-  inp: [G; IN_465],
+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_465], ExecError> {
+) -> Result<[G; OUT_468], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -42220,21 +41663,21 @@ fn aiur_fn_465(
       7u64 => {
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_7, __v_4]; 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 __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_7, __v_4]; 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_10, __v_1, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_465] = [__v_11];
-                record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_468] = [__v_11];
+                record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_465] = [__v_11];
-                record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_468] = [__v_11];
+                record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -42244,31 +41687,31 @@ fn aiur_fn_465(
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_465] = [__v_9];
-            record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_468] = [__v_9];
+            record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_465] = [__v_9];
-        record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_468] = [__v_9];
+        record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_466: usize = 2;
-const IN_466: usize = 2;
-const OUT_466: usize = 1;
-fn aiur_fn_466(
-  inp: [G; IN_466],
+const INPUT_SIZE_469: usize = 2;
+const IN_469: usize = 2;
+const OUT_469: usize = 1;
+fn aiur_fn_469(
+  inp: [G; IN_469],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_466], ExecError> {
+) -> Result<[G; OUT_469], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -42281,50 +41724,50 @@ fn aiur_fn_466(
       7u64 => {
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4]; 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 __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4]; 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_466] = [__v_6];
-            record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_469] = [__v_6];
+            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_466] = [__v_6];
-            record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_469] = [__v_6];
+            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
+        let __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_466] = [__v_8];
-        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_469] = [__v_8];
+        record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_466] = [__v_6];
-        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_469] = [__v_6];
+        record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_467: usize = 2;
-const IN_467: usize = 2;
-const OUT_467: usize = 3;
-fn aiur_fn_467(
-  inp: [G; IN_467],
+const INPUT_SIZE_470: usize = 2;
+const IN_470: usize = 2;
+const OUT_470: usize = 3;
+fn aiur_fn_470(
+  inp: [G; IN_470],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_467], ExecError> {
+) -> Result<[G; OUT_470], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -42341,10 +41784,10 @@ fn aiur_fn_467(
             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_340] = { let __args: [G; IN_340] = [__v_9]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_467] = [__v_6, __v_10, __v_4];
-            record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_470] = [__v_6, __v_10, __v_4];
+            record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -42352,8 +41795,8 @@ fn aiur_fn_467(
             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_467] = [__v_6, __v_0, __v_9];
-            record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_470] = [__v_6, __v_0, __v_9];
+            record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42366,23 +41809,23 @@ fn aiur_fn_467(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
+            let __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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_10, __v_11]; 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];
             match __v_12.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_4, __v_1]; 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_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_305] = { let __args: [G; IN_305] = [__v_15]; 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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_15]; 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_17: G = __r_arr[0];
-                let __ret: [G; OUT_467] = [__v_16, __v_14, __v_17];
-                record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_470] = [__v_16, __v_14, __v_17];
+                record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -42390,8 +41833,8 @@ fn aiur_fn_467(
                 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_467] = [__v_13, __v_0, __v_16];
-                record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_470] = [__v_13, __v_0, __v_16];
+                record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -42407,11 +41850,11 @@ fn aiur_fn_467(
             let __v_13: G = __loaded[3];
             match __v_10.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
-                let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+                let __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_15: G = __r_arr[0];
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_14, __v_15]; 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_16: G = __r_arr[0];
                 match __v_16.as_canonical_u64() {
                   1u64 => {
@@ -42424,23 +41867,23 @@ fn aiur_fn_467(
                       7u64 => {
                         match __v_18.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_8, __v_1]; 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 __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_8, __v_1]; 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_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_307] = { let __args: [G; IN_307] = [__v_23, __v_19]; 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 __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_23, __v_19]; 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_25: G = __r_arr[0];
-                                let __ret: [G; OUT_467] = [__v_24, __v_22, __v_25];
-                                record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_470] = [__v_24, __v_22, __v_25];
+                                record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
                                 let __v_24: G = G::from_u64(1);
-                                let __ret: [G; OUT_467] = [__v_24, __v_8, __v_19];
-                                record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_470] = [__v_24, __v_8, __v_19];
+                                record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -42453,8 +41896,8 @@ fn aiur_fn_467(
                             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_467] = [__v_21, __v_0, __v_24];
-                            record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_470] = [__v_21, __v_0, __v_24];
+                            record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -42464,8 +41907,8 @@ fn aiur_fn_467(
                         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_467] = [__v_21, __v_0, __v_24];
-                        record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_470] = [__v_21, __v_0, __v_24];
+                        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -42475,8 +41918,8 @@ fn aiur_fn_467(
                     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_467] = [__v_17, __v_0, __v_20];
-                    record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_470] = [__v_17, __v_0, __v_20];
+                    record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -42489,8 +41932,8 @@ fn aiur_fn_467(
                 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_467] = [__v_14, __v_0, __v_17];
-                record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_470] = [__v_14, __v_0, __v_17];
+                record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -42500,8 +41943,8 @@ fn aiur_fn_467(
             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_467] = [__v_10, __v_0, __v_13];
-            record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_470] = [__v_10, __v_0, __v_13];
+            record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42511,48 +41954,48 @@ fn aiur_fn_467(
         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_467] = [__v_6, __v_0, __v_9];
-        record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_470] = [__v_6, __v_0, __v_9];
+        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_468: usize = 5;
-const IN_468: usize = 5;
-const OUT_468: usize = 2;
-fn aiur_fn_468(
-  inp: [G; IN_468],
+const INPUT_SIZE_471: usize = 5;
+const IN_471: usize = 5;
+const OUT_471: usize = 2;
+fn aiur_fn_471(
+  inp: [G; IN_471],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_468], ExecError> {
+) -> Result<[G; OUT_471], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_0, __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 __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_1, __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 __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __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_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_468] = [__v_8, __v_9];
-        record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_471] = [__v_8, __v_9];
+        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __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 __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         let __v_10: G = __r_arr[2];
-        let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_1, __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 __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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -42561,27 +42004,27 @@ fn aiur_fn_468(
           0u64 => {
             let __v_15: G = G::from_u64(0);
             let __v_16: G = G::from_u64(0);
-            let __ret: [G; OUT_468] = [__v_15, __v_16];
-            record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_15, __v_16];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_10, __v_13]; 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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_10, __v_13]; 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_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_468] = [__v_16, __v_17];
-                record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_16, __v_17];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_16: G = G::from_u64(1);
-                let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_9, __v_12, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_9, __v_12, __v_2, __v_3, __v_4]; 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_17: G = __r_arr[0];
-                let __ret: [G; OUT_468] = [__v_16, __v_17];
-                record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_16, __v_17];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -42598,22 +42041,22 @@ fn aiur_fn_468(
   })
 }
 
-const INPUT_SIZE_469: usize = 5;
-const IN_469: usize = 5;
-const OUT_469: usize = 1;
-fn aiur_fn_469(
-  inp: [G; IN_469],
+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_469], ExecError> {
+) -> Result<[G; OUT_472], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !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_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 };
@@ -42623,7 +42066,7 @@ fn aiur_fn_469(
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __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];
@@ -42639,13 +42082,13 @@ fn aiur_fn_469(
         let __v_22: G = __loaded[10];
         match __v_12.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
             let __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_767] = { let __args: [G; IN_767] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_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];
@@ -42662,7 +42105,7 @@ fn aiur_fn_469(
                 match __v_27.as_canonical_u64() {
                   5u64 => {
                     let __v_38: G = G::from_bool((__v_31 == G::ZERO));
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
                     let __v_39: G = __r_arr[0];
                     let __v_40: G = G::from_u64(1);
                     let __v_41: G = (__v_39 - __v_40);
@@ -42671,26 +42114,26 @@ fn aiur_fn_469(
                     match __v_43.as_canonical_u64() {
                       0u64 => {
                         let __v_44: G = G::from_u64(0);
-                        let __ret: [G; OUT_469] = [__v_44];
-                        record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_472] = [__v_44];
+                        record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       1u64 => {
-                        let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_15, __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 __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_15, __v_3]; 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_44: G = __r_arr[0];
                         match __v_44.as_canonical_u64() {
                           1u64 => {
                             let __v_45: G = G::from_u64(0);
-                            let __ret: [G; OUT_469] = [__v_45];
-                            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_472] = [__v_45];
+                            record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
                             let __v_45: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_15, __v_17, __v_18, __v_0, __v_6, __v_45, __v_2, __v_3, __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 __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_15, __v_17, __v_18, __v_0, __v_6, __v_45, __v_2, __v_3, __v_4]; 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_46: G = __r_arr[0];
-                            let __ret: [G; OUT_469] = [__v_46];
-                            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_472] = [__v_46];
+                            record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -42705,47 +42148,47 @@ fn aiur_fn_469(
                   },
                   _ => {
                     let __v_38: G = G::from_u64(0);
-                    let __ret: [G; OUT_469] = [__v_38];
-                    record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_472] = [__v_38];
+                    record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_26: G = G::from_u64(0);
-                let __ret: [G; OUT_469] = [__v_26];
-                record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_472] = [__v_26];
+                record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_23: G = G::from_u64(0);
-            let __ret: [G; OUT_469] = [__v_23];
-            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_472] = [__v_23];
+            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_469] = [__v_11];
-        record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_472] = [__v_11];
+        record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_470: usize = 9;
-const IN_470: usize = 9;
-const OUT_470: usize = 1;
-fn aiur_fn_470(
-  inp: [G; IN_470],
+const INPUT_SIZE_473: usize = 9;
+const IN_473: usize = 9;
+const OUT_473: usize = 1;
+fn aiur_fn_473(
+  inp: [G; IN_473],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_470], ExecError> {
+) -> Result<[G; OUT_473], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -42760,32 +42203,32 @@ fn aiur_fn_470(
     match __v_9.as_canonical_u64() {
       0u64 => {
         let __v_10: G = G::from_u64(1);
-        let __ret: [G; OUT_470] = [__v_10];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_473] = [__v_10];
+        record.function_queries[473].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_767] = { let __args: [G; IN_767] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_11, __v_13, __v_6, __v_7, __v_8]; 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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_11, __v_13, __v_6, __v_7, __v_8]; 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_14: G = __r_arr[0];
         match __v_14.as_canonical_u64() {
           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));
+            let __ret: [G; OUT_473] = [__v_15];
+            record.function_queries[473].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_470] = { let __args: [G; IN_470] = [__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[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 __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__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[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_17: G = __r_arr[0];
-            let __ret: [G; OUT_470] = [__v_17];
-            record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_473] = [__v_17];
+            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -42797,15 +42240,15 @@ fn aiur_fn_470(
   })
 }
 
-const INPUT_SIZE_471: usize = 5;
-const IN_471: usize = 5;
-const OUT_471: usize = 1;
-fn aiur_fn_471(
-  inp: [G; IN_471],
+const INPUT_SIZE_474: usize = 5;
+const IN_474: usize = 5;
+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_471], ExecError> {
+) -> Result<[G; OUT_474], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -42826,23 +42269,23 @@ fn aiur_fn_471(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_10]; 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_6, __v_10]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_10, __v_11, __v_0, __v_2, __v_3, __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_13: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].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));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42859,29 +42302,29 @@ fn aiur_fn_471(
             match __v_13.as_canonical_u64() {
               0u64 => {
                 let __v_14: G = G::from_u64(1);
-                let __ret: [G; OUT_471] = [__v_14];
-                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_14];
+                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_471] = [__v_14];
-                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_14];
+                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_10, __v_11, __v_0, __v_2, __v_3, __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_13: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].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));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42897,31 +42340,31 @@ fn aiur_fn_471(
             let __v_13: G = (__v_6 - __v_10);
             match __v_13.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_7, __v_11]; 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 __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_7, __v_11]; 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_14: G = __r_arr[0];
-                let __ret: [G; OUT_471] = [__v_14];
-                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_14];
+                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_471] = [__v_14];
-                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_14];
+                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_10, __v_11, __v_0, __v_2, __v_3, __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_13: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].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));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42934,20 +42377,20 @@ fn aiur_fn_471(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_6, __v_10, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
             match __v_13.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_7, __v_11, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_7, __v_11, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0];
-                let __ret: [G; OUT_471] = [__v_14];
-                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_14];
+                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_471] = [__v_14];
-                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_14];
+                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -42956,16 +42399,16 @@ fn aiur_fn_471(
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_10, __v_11, __v_0, __v_2, __v_3, __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_13: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].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));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42978,22 +42421,22 @@ fn aiur_fn_471(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_6, __v_10, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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_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_457] = { let __args: [G; IN_457] = [__v_7, __v_11, __v_15, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_7, __v_11, __v_15, __v_3, __v_4]; 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_16: G = __r_arr[0];
-                let __ret: [G; OUT_471] = [__v_16];
-                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_16];
+                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_471] = [__v_14];
-                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_14];
+                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43002,10 +42445,10 @@ fn aiur_fn_471(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_7, __v_1, __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 __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_6, __v_7, __v_1, __v_2, __v_3, __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_13: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43018,22 +42461,22 @@ fn aiur_fn_471(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_6, __v_10, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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_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_457] = { let __args: [G; IN_457] = [__v_7, __v_11, __v_15, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_7, __v_11, __v_15, __v_3, __v_4]; 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_16: G = __r_arr[0];
-                let __ret: [G; OUT_471] = [__v_16];
-                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_16];
+                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_471] = [__v_14];
-                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_14];
+                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43042,16 +42485,16 @@ fn aiur_fn_471(
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_10, __v_11, __v_0, __v_2, __v_3, __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_13: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].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));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43064,26 +42507,26 @@ fn aiur_fn_471(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_6, __v_10, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
             match __v_13.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_7, __v_11, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_7, __v_11, __v_2, __v_3, __v_4]; 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_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_457] = { let __args: [G; IN_457] = [__v_8, __v_12, __v_16, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_8, __v_12, __v_16, __v_3, __v_4]; 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_17: G = __r_arr[0];
-                    let __ret: [G; OUT_471] = [__v_17];
-                    record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_474] = [__v_17];
+                    record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_15: G = G::from_u64(0);
-                    let __ret: [G; OUT_471] = [__v_15];
-                    record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_474] = [__v_15];
+                    record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -43093,8 +42536,8 @@ fn aiur_fn_471(
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_471] = [__v_14];
-                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_14];
+                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43103,16 +42546,16 @@ fn aiur_fn_471(
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_10, __v_11, __v_0, __v_2, __v_3, __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_13: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].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));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43125,23 +42568,23 @@ fn aiur_fn_471(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_6, __v_7, __v_10, __v_11]; 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 __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_6, __v_7, __v_10, __v_11]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_10, __v_11, __v_0, __v_2, __v_3, __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_13: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].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));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43161,16 +42604,16 @@ fn aiur_fn_471(
             let __v_17: G = (__v_14 * __v_16);
             match __v_17.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_8, __v_12, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_8, __v_12, __v_2, __v_3, __v_4]; 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_18: G = __r_arr[0];
-                let __ret: [G; OUT_471] = [__v_18];
-                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_18];
+                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 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));
+                let __ret: [G; OUT_474] = [__v_18];
+                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43179,16 +42622,16 @@ fn aiur_fn_471(
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_10, __v_11, __v_0, __v_2, __v_3, __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_13: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].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));
+            let __ret: [G; OUT_474] = [__v_13];
+            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43200,15 +42643,15 @@ fn aiur_fn_471(
   })
 }
 
-const INPUT_SIZE_472: usize = 6;
-const IN_472: usize = 6;
-const OUT_472: usize = 1;
-fn aiur_fn_472(
-  inp: [G; IN_472],
+const INPUT_SIZE_475: usize = 6;
+const IN_475: usize = 6;
+const OUT_475: usize = 1;
+fn aiur_fn_475(
+  inp: [G; IN_475],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_472], ExecError> {
+) -> Result<[G; OUT_475], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -43218,7 +42661,7 @@ fn aiur_fn_472(
     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_395] = { let __args: [G; IN_395] = [__v_2, __v_6, __v_7]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_2, __v_6, __v_7]; 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(0);
     let __v_10: G = G::from_u64(0);
@@ -43229,23 +42672,23 @@ fn aiur_fn_472(
     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_457] = { let __args: [G; IN_457] = [__v_1, __v_15, __v_17, __v_4, __v_5]; 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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_1, __v_15, __v_17, __v_4, __v_5]; 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_18: G = __r_arr[0];
-    let __ret: [G; OUT_472] = [__v_18];
-    record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_475] = [__v_18];
+    record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_473: usize = 2;
-const IN_473: usize = 2;
-const OUT_473: usize = 1;
-fn aiur_fn_473(
-  inp: [G; IN_473],
+const INPUT_SIZE_476: usize = 2;
+const IN_476: usize = 2;
+const OUT_476: usize = 1;
+fn aiur_fn_476(
+  inp: [G; IN_476],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_473], ExecError> {
+) -> Result<[G; OUT_476], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -43262,14 +42705,14 @@ fn aiur_fn_473(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_473] = [__v_8];
-            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_476] = [__v_8];
+            record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_473] = [__v_8];
-            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_476] = [__v_8];
+            record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43282,25 +42725,25 @@ fn aiur_fn_473(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_473] = [__v_8];
-            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_476] = [__v_8];
+            record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_3, __v_6]; 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_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_473] = [__v_9];
-                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_476] = [__v_9];
+                record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_473] = [__v_9];
-                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_476] = [__v_9];
+                record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43320,25 +42763,25 @@ fn aiur_fn_473(
   })
 }
 
-const INPUT_SIZE_474: usize = 5;
-const IN_474: usize = 5;
-const OUT_474: usize = 1;
-fn aiur_fn_474(
-  inp: [G; IN_474],
+const INPUT_SIZE_477: usize = 5;
+const IN_477: usize = 5;
+const OUT_477: usize = 1;
+fn aiur_fn_477(
+  inp: [G; IN_477],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_474], ExecError> {
+) -> Result<[G; OUT_477], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __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 };
@@ -43358,33 +42801,33 @@ fn aiur_fn_474(
             let __v_17: G = (__v_10 - __v_14);
             match __v_17.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_11, __v_15]; 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 __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_11, __v_15]; 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_18: G = __r_arr[0];
                 match __v_18.as_canonical_u64() {
                   0u64 => {
                     let __v_19: G = G::from_u64(0);
-                    let __ret: [G; OUT_474] = [__v_19];
-                    record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_477] = [__v_19];
+                    record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
                     let __v_19: G = __r_arr[0];
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_8]; 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_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_475] = { let __args: [G; IN_475] = [__v_6, __v_8, __v_2, __v_3, __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 __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_6, __v_8, __v_2, __v_3, __v_4]; 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_22: G = __r_arr[0];
-                        let __ret: [G; OUT_474] = [__v_22];
-                        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_477] = [__v_22];
+                        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_22: G = G::from_u64(0);
-                        let __ret: [G; OUT_474] = [__v_22];
-                        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_477] = [__v_22];
+                        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -43396,39 +42839,39 @@ fn aiur_fn_474(
               },
               _ => {
                 let __v_18: G = G::from_u64(0);
-                let __ret: [G; OUT_474] = [__v_18];
-                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_477] = [__v_18];
+                record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_17: G = G::from_u64(0);
-            let __ret: [G; OUT_474] = [__v_17];
-            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_477] = [__v_17];
+            record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_474] = [__v_13];
-        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_477] = [__v_13];
+        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_475: usize = 5;
-const IN_475: usize = 5;
-const OUT_475: usize = 1;
-fn aiur_fn_475(
-  inp: [G; IN_475],
+const INPUT_SIZE_478: usize = 5;
+const IN_478: usize = 5;
+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_475], ExecError> {
+) -> Result<[G; OUT_478], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -43448,14 +42891,14 @@ fn aiur_fn_475(
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __v_11: G = G::from_u64(1);
-            let __ret: [G; OUT_475] = [__v_11];
-            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_478] = [__v_11];
+            record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_475] = [__v_11];
-            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_478] = [__v_11];
+            record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43468,25 +42911,25 @@ fn aiur_fn_475(
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_475] = [__v_11];
-            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_478] = [__v_11];
+            record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_6, __v_9, __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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_9, __v_2, __v_3, __v_4]; 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_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               0u64 => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_475] = [__v_12];
-                record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_478] = [__v_12];
+                record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_10, __v_2, __v_3, __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 __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_7, __v_10, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0];
-                let __ret: [G; OUT_475] = [__v_12];
-                record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_478] = [__v_12];
+                record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43506,19 +42949,19 @@ fn aiur_fn_475(
   })
 }
 
-const INPUT_SIZE_476: usize = 2;
-const IN_476: usize = 2;
-const OUT_476: usize = 1;
-fn aiur_fn_476(
-  inp: [G; IN_476],
+const INPUT_SIZE_479: usize = 2;
+const IN_479: usize = 2;
+const OUT_479: usize = 1;
+fn aiur_fn_479(
+  inp: [G; IN_479],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_476], ExecError> {
+) -> Result<[G; OUT_479], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_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];
@@ -43535,39 +42978,39 @@ fn aiur_fn_476(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_14: G = G::from_u64(1);
-        let __ret: [G; OUT_476] = [__v_14];
-        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_479] = [__v_14];
+        record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_14: G = G::from_u64(1);
-        let __ret: [G; OUT_476] = [__v_14];
-        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_479] = [__v_14];
+        record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_476] = [__v_14];
-        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_479] = [__v_14];
+        record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_477: usize = 2;
-const IN_477: usize = 2;
-const OUT_477: usize = 1;
-fn aiur_fn_477(
-  inp: [G; IN_477],
+const INPUT_SIZE_480: usize = 2;
+const IN_480: usize = 2;
+const OUT_480: usize = 1;
+fn aiur_fn_480(
+  inp: [G; IN_480],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_477], ExecError> {
+) -> Result<[G; OUT_480], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_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];
@@ -43583,33 +43026,33 @@ fn aiur_fn_477(
     let __v_13: G = __loaded[10];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_477] = [__v_8];
-        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_480] = [__v_8];
+        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_477] = [__v_14];
-        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_480] = [__v_14];
+        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_478: usize = 2;
-const IN_478: usize = 2;
-const OUT_478: usize = 2;
-fn aiur_fn_478(
-  inp: [G; IN_478],
+const INPUT_SIZE_481: usize = 2;
+const IN_481: usize = 2;
+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_478], ExecError> {
+) -> Result<[G; OUT_481], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_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 };
@@ -43619,7 +43062,7 @@ fn aiur_fn_478(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __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];
@@ -43635,56 +43078,56 @@ fn aiur_fn_478(
         let __v_19: G = __loaded[10];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_12, __v_6]; 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_12, __v_6]; 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_20: G = __r_arr[0];
             let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_20, __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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_20, __v_3]; 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_478] = [__v_21, __v_22];
-            record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_481] = [__v_21, __v_22];
+            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_12, __v_6]; 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_12, __v_6]; 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_20: G = __r_arr[0];
             let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_20, __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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_20, __v_3]; 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_478] = [__v_21, __v_22];
-            record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_481] = [__v_21, __v_22];
+            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_20: G = G::from_u64(0);
-            let __ret: [G; OUT_478] = [__v_20, __v_0];
-            record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_481] = [__v_20, __v_0];
+            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_478] = [__v_8, __v_0];
-        record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_481] = [__v_8, __v_0];
+        record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_479: usize = 2;
-const IN_479: usize = 2;
-const OUT_479: usize = 2;
-fn aiur_fn_479(
-  inp: [G; IN_479],
+const INPUT_SIZE_482: usize = 2;
+const IN_482: usize = 2;
+const OUT_482: usize = 2;
+fn aiur_fn_482(
+  inp: [G; IN_482],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_479], ExecError> {
+) -> Result<[G; OUT_482], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_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 };
@@ -43694,7 +43137,7 @@ fn aiur_fn_479(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       8u64 => {
-        let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_7, __v_1]; 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 __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_7, __v_1]; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
@@ -43702,16 +43145,16 @@ fn aiur_fn_479(
             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_404] = { let __args: [G; IN_404] = [__v_11, __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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_11, __v_3]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_479] = [__v_12, __v_13];
-            record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_482] = [__v_12, __v_13];
+            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_479] = [__v_10, __v_0];
-            record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_482] = [__v_10, __v_0];
+            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -43721,23 +43164,23 @@ fn aiur_fn_479(
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_479] = [__v_8, __v_0];
-        record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_482] = [__v_8, __v_0];
+        record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_480: usize = 6;
-const IN_480: usize = 6;
-const OUT_480: usize = 2;
-fn aiur_fn_480(
-  inp: [G; IN_480],
+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_480], ExecError> {
+) -> Result<[G; OUT_483], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -43749,8 +43192,8 @@ fn aiur_fn_480(
       0u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_480] = [__v_6, __v_7];
-        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_483] = [__v_6, __v_7];
+        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -43759,15 +43202,15 @@ fn aiur_fn_480(
           0u64 => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_480] = [__v_7, __v_8];
-            record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_483] = [__v_7, __v_8];
+            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __v_8: G = __r_arr[1];
-            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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __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 };
@@ -43784,32 +43227,32 @@ fn aiur_fn_480(
                 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_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[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 __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__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[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_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_480] = [__v_20, __v_21];
-                        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_483] = [__v_20, __v_21];
+                        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__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[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 __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__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[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_20: G = __r_arr[0];
                         let __v_21: G = __r_arr[1];
-                        let __ret: [G; OUT_480] = [__v_20, __v_21];
-                        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_483] = [__v_20, __v_21];
+                        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_12, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_12, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_19: G = __r_arr[0];
                     let __v_20: G = __r_arr[1];
-                    let __ret: [G; OUT_480] = [__v_19, __v_20];
-                    record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_483] = [__v_19, __v_20];
+                    record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -43822,18 +43265,18 @@ fn aiur_fn_480(
                 let __v_18: G = __loaded[3];
                 match __v_15.as_canonical_u64() {
                   2u64 => {
-                    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __v_19: G = __r_arr[0];
                     let __v_20: G = __r_arr[1];
-                    let __ret: [G; OUT_480] = [__v_19, __v_20];
-                    record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_483] = [__v_19, __v_20];
+                    record.function_queries[483].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_480] = [__v_19, __v_20];
-                    record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_483] = [__v_19, __v_20];
+                    record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -43846,15 +43289,15 @@ fn aiur_fn_480(
   })
 }
 
-const INPUT_SIZE_481: usize = 9;
-const IN_481: usize = 9;
-const OUT_481: usize = 1;
-fn aiur_fn_481(
-  inp: [G; IN_481],
+const INPUT_SIZE_484: usize = 9;
+const IN_484: usize = 9;
+const OUT_484: usize = 1;
+fn aiur_fn_484(
+  inp: [G; IN_484],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_481], ExecError> {
+) -> Result<[G; OUT_484], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -43868,33 +43311,33 @@ fn aiur_fn_481(
     let __v_9: G = (__v_0 - __v_3);
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_1, __v_4]; 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_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           0u64 => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_481] = [__v_11];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_484] = [__v_11];
+            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2]; 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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5]; 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_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_475] = { let __args: [G; IN_475] = [__v_2, __v_5, __v_6, __v_7, __v_8]; 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 __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_2, __v_5, __v_6, __v_7, __v_8]; 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_14: G = __r_arr[0];
-                let __ret: [G; OUT_481] = [__v_14];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_484] = [__v_14];
+                record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_481] = [__v_14];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_484] = [__v_14];
+                record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -43906,23 +43349,23 @@ fn aiur_fn_481(
       },
       _ => {
         let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_481] = [__v_10];
-        record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_484] = [__v_10];
+        record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_482: usize = 8;
-const IN_482: usize = 8;
-const OUT_482: usize = 2;
-fn aiur_fn_482(
-  inp: [G; IN_482],
+const INPUT_SIZE_485: usize = 8;
+const IN_485: usize = 8;
+const OUT_485: usize = 2;
+fn aiur_fn_485(
+  inp: [G; IN_485],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_482], ExecError> {
+) -> Result<[G; OUT_485], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -43932,9 +43375,9 @@ fn aiur_fn_482(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; 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 __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __v_6]; 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_1, __v_6]; 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 __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_6]; 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_9: G = __r_arr[0];
     match __v_8.as_canonical_u64() {
       0u64 => {
@@ -43942,23 +43385,23 @@ fn aiur_fn_482(
           0u64 => {
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_482] = [__v_10, __v_11];
-            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_10, __v_11];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_2, __v_3, __v_4, __v_5, __v_6, __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 __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_2, __v_3, __v_4, __v_5, __v_6, __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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_482] = [__v_10, __v_11];
-            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_10, __v_11];
+            record.function_queries[485].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_482] = [__v_10, __v_11];
-            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_10, __v_11];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43966,45 +43409,45 @@ fn aiur_fn_482(
       1u64 => {
         match __v_9.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_482] = [__v_10, __v_11];
-            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_10, __v_11];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __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 __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_6]; 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_1, __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 __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1, __v_6]; 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_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_485] = { let __args: [G; IN_485] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_482] = [__v_13, __v_14];
-                record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_13, __v_14];
+                record.function_queries[485].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_486] = { let __args: [G; IN_486] = [__v_2, __v_3, __v_4, __v_5, __v_6, __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 __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_2, __v_3, __v_4, __v_5, __v_6, __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_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
-                    let __ret: [G; OUT_482] = [__v_14, __v_15];
-                    record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_485] = [__v_14, __v_15];
+                    record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_490] = { let __args: [G; IN_490] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
-                    let __ret: [G; OUT_482] = [__v_14, __v_15];
-                    record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_485] = [__v_14, __v_15];
+                    record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -44020,8 +43463,8 @@ fn aiur_fn_482(
           _ => {
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_482] = [__v_10, __v_11];
-            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_10, __v_11];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -44029,23 +43472,23 @@ fn aiur_fn_482(
       _ => {
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_482] = [__v_10, __v_11];
-        record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_485] = [__v_10, __v_11];
+        record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_483: usize = 7;
-const IN_483: usize = 7;
-const OUT_483: usize = 2;
-fn aiur_fn_483(
-  inp: [G; IN_483],
+const INPUT_SIZE_486: usize = 7;
+const IN_486: usize = 7;
+const OUT_486: usize = 2;
+fn aiur_fn_486(
+  inp: [G; IN_486],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_483], ExecError> {
+) -> Result<[G; OUT_486], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44054,39 +43497,39 @@ fn aiur_fn_483(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __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 __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __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_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_483] = [__v_8, __v_9];
-        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_486] = [__v_8, __v_9];
+        record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_2, __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 __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_5]; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_9, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_9, __v_4, __v_5, __v_6]; 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_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_480] = { let __args: [G; IN_480] = [__v_1, __v_10, __v_12, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_10, __v_12, __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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_483] = [__v_13, __v_14];
-            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_486] = [__v_13, __v_14];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_483] = [__v_10, __v_11];
-            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_486] = [__v_10, __v_11];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44097,23 +43540,23 @@ fn aiur_fn_483(
       _ => {
         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));
+        let __ret: [G; OUT_486] = [__v_8, __v_9];
+        record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_484: usize = 7;
-const IN_484: usize = 7;
-const OUT_484: usize = 2;
-fn aiur_fn_484(
-  inp: [G; IN_484],
+const INPUT_SIZE_487: usize = 7;
+const IN_487: usize = 7;
+const OUT_487: usize = 2;
+fn aiur_fn_487(
+  inp: [G; IN_487],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_484], ExecError> {
+) -> Result<[G; OUT_487], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44122,39 +43565,39 @@ fn aiur_fn_484(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __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 __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __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_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_484] = [__v_8, __v_9];
-        record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_487] = [__v_8, __v_9];
+        record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __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 __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_5]; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_9, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_9, __v_4, __v_5, __v_6]; 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_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_480] = { let __args: [G; IN_480] = [__v_10, __v_2, __v_12, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_10, __v_2, __v_12, __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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_484] = [__v_13, __v_14];
-            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_487] = [__v_13, __v_14];
+            record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_2, __v_3, __v_4, __v_5, __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 __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_484] = [__v_10, __v_11];
-            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_487] = [__v_10, __v_11];
+            record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44165,23 +43608,23 @@ fn aiur_fn_484(
       _ => {
         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));
+        let __ret: [G; OUT_487] = [__v_8, __v_9];
+        record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_485: usize = 6;
-const IN_485: usize = 6;
-const OUT_485: usize = 2;
-fn aiur_fn_485(
-  inp: [G; IN_485],
+const INPUT_SIZE_488: usize = 6;
+const IN_488: usize = 6;
+const OUT_488: usize = 2;
+fn aiur_fn_488(
+  inp: [G; IN_488],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_485], ExecError> {
+) -> Result<[G; OUT_488], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44189,27 +43632,27 @@ fn aiur_fn_485(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_4]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_7, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_7, __v_3, __v_4, __v_5]; 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_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_480] = { let __args: [G; IN_480] = [__v_8, __v_1, __v_10, __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 __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_8, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_485] = [__v_11, __v_12];
-        record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_488] = [__v_11, __v_12];
+        record.function_queries[488].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_485] = [__v_8, __v_9];
-        record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_488] = [__v_8, __v_9];
+        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44219,15 +43662,15 @@ fn aiur_fn_485(
   })
 }
 
-const INPUT_SIZE_486: usize = 6;
-const IN_486: usize = 6;
-const OUT_486: usize = 2;
-fn aiur_fn_486(
-  inp: [G; IN_486],
+const INPUT_SIZE_489: usize = 6;
+const IN_489: usize = 6;
+const OUT_489: usize = 2;
+fn aiur_fn_489(
+  inp: [G; IN_489],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_486], ExecError> {
+) -> Result<[G; OUT_489], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44235,27 +43678,27 @@ fn aiur_fn_486(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_4]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_7, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_7, __v_3, __v_4, __v_5]; 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_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_480] = { let __args: [G; IN_480] = [__v_0, __v_8, __v_10, __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 __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_8, __v_10, __v_3, __v_4, __v_5]; 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_486] = [__v_11, __v_12];
-        record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_489] = [__v_11, __v_12];
+        record.function_queries[489].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_486] = [__v_8, __v_9];
-        record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_489] = [__v_8, __v_9];
+        record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44265,15 +43708,15 @@ fn aiur_fn_486(
   })
 }
 
-const INPUT_SIZE_487: usize = 6;
-const IN_487: usize = 6;
-const OUT_487: usize = 2;
-fn aiur_fn_487(
-  inp: [G; IN_487],
+const INPUT_SIZE_490: usize = 6;
+const IN_490: usize = 6;
+const OUT_490: usize = 2;
+fn aiur_fn_490(
+  inp: [G; IN_490],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_487], ExecError> {
+) -> Result<[G; OUT_490], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44281,34 +43724,34 @@ fn aiur_fn_487(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_4]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __v_4]; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_7, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_7, __v_3, __v_4, __v_5]; 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_9, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_9, __v_3, __v_4, __v_5]; 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_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_480] = { let __args: [G; IN_480] = [__v_10, __v_11, __v_13, __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 __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_10, __v_11, __v_13, __v_3, __v_4, __v_5]; 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_487] = [__v_14, __v_15];
-            record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_490] = [__v_14, __v_15];
+            record.function_queries[490].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_487] = [__v_10, __v_11];
-            record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_490] = [__v_10, __v_11];
+            record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44319,8 +43762,8 @@ fn aiur_fn_487(
       0u64 => {
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_487] = [__v_8, __v_9];
-        record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_490] = [__v_8, __v_9];
+        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44330,15 +43773,15 @@ fn aiur_fn_487(
   })
 }
 
-const INPUT_SIZE_488: usize = 7;
-const IN_488: usize = 7;
-const OUT_488: usize = 0;
-fn aiur_fn_488(
-  inp: [G; IN_488],
+const INPUT_SIZE_491: usize = 7;
+const IN_491: usize = 7;
+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_488], ExecError> {
+) -> Result<[G; OUT_491], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44348,9 +43791,9 @@ fn aiur_fn_488(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = (__v_1 + __v_3);
-    let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __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 __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __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 __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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__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_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 };
@@ -44360,31 +43803,31 @@ fn aiur_fn_488(
     let __v_14: G = __loaded[3];
     match __v_11.as_canonical_u64() {
       2u64 => {
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_13, __v_5, __v_15]; 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 __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_10]; 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_16: G = __r_arr[0];
+        let __v_17: G = G::from_u64(0);
+        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_10, __v_1, __v_3, __v_17]; 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_788] = { let __args: [G; IN_788] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__args, record, io_buffer, __cu)? } };
+        let __v_18: G = __r_arr[0];
+        let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_4, __v_6]; 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_19: G = __r_arr[0];
         if (__v_12 != __v_4) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
         }
-        let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_13, __v_5, __v_15]; 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 __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_10]; 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_16: G = __r_arr[0];
-        let __v_17: G = (__v_1 + __v_2);
-        if (__v_16 != __v_17) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
+        let __v_20: G = (__v_1 + __v_2);
+        if (__v_16 != __v_20) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
         }
-        let __v_18: G = G::from_u64(0);
-        let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_10, __v_1, __v_3, __v_18]; 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 __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_4, __v_6]; 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_19, __v_20]; 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 __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_18, __v_19]; 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_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 __ret: [G; OUT_488] = [];
-        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_491] = [];
+        record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44394,20 +43837,20 @@ fn aiur_fn_488(
   })
 }
 
-const INPUT_SIZE_489: usize = 3;
-const IN_489: usize = 3;
-const OUT_489: usize = 0;
-fn aiur_fn_489(
-  inp: [G; IN_489],
+const INPUT_SIZE_492: usize = 3;
+const IN_492: usize = 3;
+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_489], ExecError> {
+) -> Result<[G; OUT_492], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __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];
@@ -44427,32 +43870,32 @@ fn aiur_fn_489(
         let __v_16: G = G::from_u64(1);
         let __v_17: G = G::from_u64(1);
         let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_6, __v_15, __v_18, __v_1, __v_2]; 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 __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_6, __v_15, __v_18, __v_1, __v_2]; 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_19: G = __r_arr[0];
         let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_9, __v_0, __v_6, __v_5, __v_7, __v_8, __v_19, __v_20, __v_1, __v_2]; 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 __ret: [G; OUT_489] = [];
-        record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_9, __v_0, __v_6, __v_5, __v_7, __v_8, __v_19, __v_20, __v_1, __v_2]; 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_492] = [];
+        record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_489] = [];
-        record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_492] = [];
+        record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_490: usize = 10;
-const IN_490: usize = 10;
-const OUT_490: usize = 0;
-fn aiur_fn_490(
-  inp: [G; IN_490],
+const INPUT_SIZE_493: usize = 10;
+const IN_493: usize = 10;
+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_490], ExecError> {
+) -> Result<[G; OUT_493], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44470,12 +43913,12 @@ fn aiur_fn_490(
     let __v_12: G = __loaded[2];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_490] = [];
-        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_493] = [];
+        record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -44491,6 +43934,16 @@ fn aiur_fn_490(
         let __v_24: G = __loaded[10];
         match __v_14.as_canonical_u64() {
           6u64 => {
+            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_2, __v_16, __v_4, __v_8, __v_9]; 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 __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_16, __v_19, __v_5, __v_20, __v_1, __v_3, __v_8]; 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 __v_25: G = G::from_u64(1);
+            let __v_26: G = G::from_u64(1);
+            let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_16, __v_19, __v_6, __v_27, __v_8, __v_9]; 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_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_501] = { let __args: [G; IN_501] = [__v_16, __v_19, __v_1, __v_30, __v_8, __v_9]; 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)? } };
             if (__v_17 != __v_1) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_1.as_canonical_u64() });
             }
@@ -44500,21 +43953,11 @@ fn aiur_fn_490(
             if (__v_19 != __v_4) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
             }
-            let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_2, __v_16, __v_4, __v_8, __v_9]; 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_488] = { let __args: [G; IN_488] = [__v_16, __v_19, __v_5, __v_20, __v_1, __v_3, __v_8]; 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 __v_25: G = G::from_u64(1);
-            let __v_26: G = G::from_u64(1);
-            let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_16, __v_19, __v_6, __v_27, __v_8, __v_9]; 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_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_498] = { let __args: [G; IN_498] = [__v_16, __v_19, __v_1, __v_30, __v_8, __v_9]; 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_31: G = G::from_u64(1);
             let __v_32: G = (__v_7 + __v_31);
-            let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_32, __v_8, __v_9]; 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 __ret: [G; OUT_490] = [];
-            record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_32, __v_8, __v_9]; 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_493] = [];
+            record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44523,8 +43966,8 @@ fn aiur_fn_490(
             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_490] = [];
-            record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_493] = [];
+            record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -44536,22 +43979,22 @@ fn aiur_fn_490(
   })
 }
 
-const INPUT_SIZE_491: usize = 2;
-const IN_491: usize = 2;
-const OUT_491: usize = 1;
-fn aiur_fn_491(
-  inp: [G; IN_491],
+const INPUT_SIZE_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_491], ExecError> {
+) -> Result<[G; OUT_494], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_491] = [__v_0];
-        record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_494] = [__v_0];
+        record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44564,10 +44007,10 @@ fn aiur_fn_491(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_4, __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 __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_491] = [__v_8];
-            record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_494] = [__v_8];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44579,29 +44022,29 @@ fn aiur_fn_491(
   })
 }
 
-const INPUT_SIZE_492: usize = 3;
-const IN_492: usize = 3;
-const OUT_492: usize = 0;
-fn aiur_fn_492(
-  inp: [G; IN_492],
+const INPUT_SIZE_495: usize = 3;
+const IN_495: usize = 3;
+const OUT_495: usize = 0;
+fn aiur_fn_495(
+  inp: [G; IN_495],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_492], ExecError> {
+) -> Result<[G; OUT_495], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_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_492] = [];
-        record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_495] = [];
+        record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44617,16 +44060,16 @@ fn aiur_fn_492(
             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_492] = { let __args: [G; IN_492] = [__v_5, __v_10, __v_12]; 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));
+                let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_10, __v_12]; 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)? } };
+                if (__v_7 != __v_2) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64() });
+                }
+                let __ret: [G; OUT_495] = [];
+                record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -44643,15 +44086,15 @@ fn aiur_fn_492(
   })
 }
 
-const INPUT_SIZE_493: usize = 4;
-const IN_493: usize = 4;
-const OUT_493: usize = 0;
-fn aiur_fn_493(
-  inp: [G; IN_493],
+const INPUT_SIZE_496: usize = 4;
+const IN_496: usize = 4;
+const OUT_496: usize = 0;
+fn aiur_fn_496(
+  inp: [G; IN_496],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_493], ExecError> {
+) -> Result<[G; OUT_496], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44660,8 +44103,8 @@ fn aiur_fn_493(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_493] = [];
-        record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_496] = [];
+        record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44678,18 +44121,18 @@ fn aiur_fn_493(
             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_12: G = G::from_u64(1);
+                let __v_13: G = (__v_3 + __v_12);
+                let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_7, __v_1, __v_2, __v_13]; 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 __v_14: G = (__v_2 + __v_1);
+                let __v_15: G = G::from_u64(1);
+                let __v_16: G = (__v_14 - __v_15);
+                let __v_17: G = (__v_16 - __v_3);
+                if (__v_9 != __v_17) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
                 }
-                let __v_16: G = G::from_u64(1);
-                let __v_17: G = (__v_3 + __v_16);
-                let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_7, __v_1, __v_2, __v_17]; 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_493] = [];
-                record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_496] = [];
+                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -44706,22 +44149,22 @@ fn aiur_fn_493(
   })
 }
 
-const INPUT_SIZE_494: usize = 5;
-const IN_494: usize = 5;
-const OUT_494: usize = 1;
-fn aiur_fn_494(
-  inp: [G; IN_494],
+const INPUT_SIZE_497: usize = 5;
+const IN_497: usize = 5;
+const OUT_497: usize = 1;
+fn aiur_fn_497(
+  inp: [G; IN_497],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_494], ExecError> {
+) -> Result<[G; OUT_497], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
     match __v_1.as_canonical_u64() {
       0u64 => {
@@ -44732,8 +44175,8 @@ fn aiur_fn_494(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_494] = [__v_7];
-            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_497] = [__v_7];
+            record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44753,10 +44196,10 @@ fn aiur_fn_494(
             let __v_11: G = (__v_1 - __v_10);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = { let __values: [G; 3] = [__v_12, __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_494] = { let __args: [G; IN_494] = [__v_8, __v_11, __v_13, __v_3, __v_4]; 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 __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_8, __v_11, __v_13, __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_14: G = __r_arr[0];
-            let __ret: [G; OUT_494] = [__v_14];
-            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_497] = [__v_14];
+            record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44768,15 +44211,15 @@ fn aiur_fn_494(
   })
 }
 
-const INPUT_SIZE_495: usize = 6;
-const IN_495: usize = 6;
-const OUT_495: usize = 0;
-fn aiur_fn_495(
-  inp: [G; IN_495],
+const INPUT_SIZE_498: usize = 6;
+const IN_498: usize = 6;
+const OUT_498: usize = 0;
+fn aiur_fn_498(
+  inp: [G; IN_498],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_495], ExecError> {
+) -> Result<[G; OUT_498], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44790,29 +44233,29 @@ fn aiur_fn_495(
     let __v_8: G = __loaded[2];
     match __v_6.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_495] = [];
-        record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_498] = [];
+        record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_0, __v_1, __v_2, __v_3, __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_495] = [];
-        record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __ret: [G; OUT_498] = [];
+        record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_496: usize = 6;
-const IN_496: usize = 6;
-const OUT_496: usize = 0;
-fn aiur_fn_496(
-  inp: [G; IN_496],
+const INPUT_SIZE_499: usize = 6;
+const IN_499: usize = 6;
+const OUT_499: usize = 0;
+fn aiur_fn_499(
+  inp: [G; IN_499],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_496], ExecError> {
+) -> Result<[G; OUT_499], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44822,9 +44265,9 @@ fn aiur_fn_496(
     let __v_5: G = inp[5];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_0, __v_2, __v_3, __v_4, __v_5]; 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_496] = [];
-        record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_2, __v_3, __v_4, __v_5]; 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 __ret: [G; OUT_499] = [];
+        record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44839,9 +44282,9 @@ fn aiur_fn_496(
             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_496] = { let __args: [G; IN_496] = [__v_8, __v_13, __v_2, __v_11, __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_496] = [];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; 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 __ret: [G; OUT_499] = [];
+            record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44853,15 +44296,15 @@ fn aiur_fn_496(
   })
 }
 
-const INPUT_SIZE_497: usize = 5;
-const IN_497: usize = 5;
-const OUT_497: usize = 0;
-fn aiur_fn_497(
-  inp: [G; IN_497],
+const INPUT_SIZE_500: usize = 5;
+const IN_500: usize = 5;
+const OUT_500: usize = 0;
+fn aiur_fn_500(
+  inp: [G; IN_500],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_497], ExecError> {
+) -> Result<[G; OUT_500], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44875,39 +44318,39 @@ fn aiur_fn_497(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_6, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_6, __v_2, __v_3, __v_4]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_9, __v_1]; 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 __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_9, __v_1]; 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_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 __v_11: G = G::from_u64(0);
+        let __v_12: G = { let __values: [G; 3] = [__v_11, __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 __v_13: G = G::from_u64(1);
+        if (__v_10 != __v_13) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
         }
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 3] = [__v_12, __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_497] = { let __args: [G; IN_497] = [__v_7, __v_1, __v_13, __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));
+        let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_7, __v_1, __v_12, __v_3, __v_4]; 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 __ret: [G; OUT_500] = [];
+        record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_497] = [];
-        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_500] = [];
+        record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_498: usize = 6;
-const IN_498: usize = 6;
-const OUT_498: usize = 0;
-fn aiur_fn_498(
-  inp: [G; IN_498],
+const INPUT_SIZE_501: usize = 6;
+const IN_501: usize = 6;
+const OUT_501: usize = 0;
+fn aiur_fn_501(
+  inp: [G; IN_501],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_498], ExecError> {
+) -> 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];
@@ -44915,34 +44358,34 @@ fn aiur_fn_498(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_1, __v_3]; 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 __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
-    let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_2, __v_4]; 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 __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_4]; 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_6, __v_8, __v_7, __v_4, __v_5]; 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 __ret: [G; OUT_498] = [];
-    record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_6, __v_8, __v_7, __v_4, __v_5]; 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 __ret: [G; OUT_501] = [];
+    record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_499: usize = 2;
-const IN_499: usize = 2;
-const OUT_499: usize = 1;
-fn aiur_fn_499(
-  inp: [G; IN_499],
+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_499], ExecError> {
+) -> 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_499] = [__v_0];
-        record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_502] = [__v_0];
+        record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44955,15 +44398,15 @@ fn aiur_fn_499(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4, __v_7]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_499] = [__v_8];
-            record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_502] = [__v_8];
+            record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_499] = [__v_0];
-            record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_502] = [__v_0];
+            record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -44972,23 +44415,23 @@ fn aiur_fn_499(
   })
 }
 
-const INPUT_SIZE_500: usize = 3;
-const IN_500: usize = 3;
-const OUT_500: usize = 2;
-fn aiur_fn_500(
-  inp: [G; IN_500],
+const INPUT_SIZE_503: usize = 3;
+const IN_503: usize = 3;
+const OUT_503: usize = 2;
+fn aiur_fn_503(
+  inp: [G; IN_503],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_500], ExecError> {
+) -> 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_500] = [__v_0, __v_2];
-        record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_503] = [__v_0, __v_2];
+        record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -45003,16 +44446,16 @@ fn aiur_fn_500(
             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_500] = { let __args: [G; IN_500] = [__v_5, __v_10, __v_8]; 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 __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_5, __v_10, __v_8]; 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_500] = [__v_11, __v_12];
-            record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_503] = [__v_11, __v_12];
+            record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_500] = [__v_0, __v_2];
-            record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_503] = [__v_0, __v_2];
+            record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45021,15 +44464,15 @@ fn aiur_fn_500(
   })
 }
 
-const INPUT_SIZE_501: usize = 5;
-const IN_501: usize = 5;
-const OUT_501: usize = 0;
-fn aiur_fn_501(
-  inp: [G; IN_501],
+const INPUT_SIZE_504: usize = 5;
+const IN_504: usize = 5;
+const OUT_504: usize = 0;
+fn aiur_fn_504(
+  inp: [G; IN_504],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_501], ExecError> {
+) -> 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];
@@ -45043,48 +44486,48 @@ fn aiur_fn_501(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_6, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_6, __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 __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_501] = { let __args: [G; IN_501] = [__v_7, __v_1, __v_10, __v_3, __v_4]; 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 __ret: [G; OUT_501] = [];
-        record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_7, __v_1, __v_10, __v_3, __v_4]; 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 __ret: [G; OUT_504] = [];
+        record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_501] = [];
-        record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_504] = [];
+        record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_502: usize = 5;
-const IN_502: usize = 5;
-const OUT_502: usize = 0;
-fn aiur_fn_502(
-  inp: [G; IN_502],
+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_502], ExecError> {
+) -> 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 __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_0, __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_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_502] = [];
-        record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_505] = [];
+        record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_2, __v_3, __v_4]; 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_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];
@@ -45093,21 +44536,21 @@ fn aiur_fn_502(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_8, __v_1]; 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_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_11: G = G::from_u64(0);
+            let __v_12: G = { let __values: [G; 3] = [__v_11, __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_510] = { let __args: [G; IN_510] = [__v_8, __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_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 __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_502] = { let __args: [G; IN_502] = [__v_9, __v_1, __v_14, __v_3, __v_4]; 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 __ret: [G; OUT_502] = [];
-            record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_9, __v_1, __v_12, __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_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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !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_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 };
@@ -45117,16 +44560,16 @@ fn aiur_fn_502(
             let __v_16: G = __loaded[3];
             match __v_13.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_1, __v_14]; 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 __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_1, __v_14]; 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_17: G = __r_arr[0];
                 match __v_17.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_502] = [];
-                    record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_767] = { let __args: [G; IN_767] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                     let __v_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];
@@ -45142,19 +44585,19 @@ fn aiur_fn_502(
                     let __v_29: G = __loaded[10];
                     match __v_19.as_canonical_u64() {
                       5u64 => {
-                        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_12, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_12, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__args, record, io_buffer, __cu)? } };
                         let __v_30: G = __r_arr[0];
-                        let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_30, __v_1]; 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 __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_1, __v_26, __v_3]; 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_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_511] = { let __args: [G; IN_511] = [__v_30, __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_32: G = __r_arr[0];
+                        let __v_33: G = G::from_u64(0);
+                        if (__v_32 != __v_33) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64() });
                         }
-                        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_1, __v_26, __v_3]; 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_33: G = __r_arr[0];
-                        let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_24, __v_12, __v_33, __v_3, __v_4]; 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 __ret: [G; OUT_502] = [];
-                        record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_24, __v_12, __v_31, __v_3, __v_4]; 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 __ret: [G; OUT_505] = [];
+                        record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -45163,8 +44606,8 @@ fn aiur_fn_502(
                         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_502] = [];
-                        record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_505] = [];
+                        record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -45180,8 +44623,8 @@ fn aiur_fn_502(
                 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_502] = [];
-                record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_505] = [];
+                record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -45192,15 +44635,15 @@ fn aiur_fn_502(
   })
 }
 
-const INPUT_SIZE_503: usize = 2;
-const IN_503: usize = 2;
-const OUT_503: usize = 1;
-fn aiur_fn_503(
-  inp: [G; IN_503],
+const INPUT_SIZE_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_503], ExecError> {
+) -> 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];
@@ -45211,8 +44654,8 @@ fn aiur_fn_503(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_503] = [__v_5];
-        record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_506] = [__v_5];
+        record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -45220,15 +44663,15 @@ fn aiur_fn_503(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_503] = [__v_6];
-            record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_506] = [__v_6];
+            record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_4, __v_1]; 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 __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_6: G = __r_arr[0];
-            let __ret: [G; OUT_503] = [__v_6];
-            record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_506] = [__v_6];
+            record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45240,19 +44683,19 @@ fn aiur_fn_503(
   })
 }
 
-const INPUT_SIZE_504: usize = 2;
-const IN_504: usize = 2;
-const OUT_504: usize = 1;
-fn aiur_fn_504(
-  inp: [G; IN_504],
+const INPUT_SIZE_507: usize = 2;
+const IN_507: usize = 2;
+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_504], ExecError> {
+) -> 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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_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];
@@ -45268,33 +44711,33 @@ fn aiur_fn_504(
     let __v_13: G = __loaded[10];
     match __v_3.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_1]; 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_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_8, __v_6, __v_14, __v_1]; 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 __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_8, __v_6, __v_14, __v_1]; 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_15: G = __r_arr[0];
-        let __ret: [G; OUT_504] = [__v_15];
-        record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_507] = [__v_15];
+        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_504] = [__v_14];
-        record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_507] = [__v_14];
+        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_505: usize = 4;
-const IN_505: usize = 4;
-const OUT_505: usize = 1;
-fn aiur_fn_505(
-  inp: [G; IN_505],
+const INPUT_SIZE_508: usize = 4;
+const IN_508: usize = 4;
+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_505], ExecError> {
+) -> 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];
@@ -45307,12 +44750,12 @@ fn aiur_fn_505(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_505] = [__v_7];
-        record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_508] = [__v_7];
+        record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __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];
@@ -45328,22 +44771,22 @@ fn aiur_fn_505(
         let __v_18: G = __loaded[10];
         match __v_8.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_10, __v_1]; 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 __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_10, __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_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_19, __v_2]; 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 __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_19, __v_2]; 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_20: G = __r_arr[0];
             match __v_20.as_canonical_u64() {
               1u64 => {
                 let __v_21: G = G::from_u64(1);
-                let __ret: [G; OUT_505] = [__v_21];
-                record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_508] = [__v_21];
+                record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_6, __v_1, __v_2, __v_3]; 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_21: G = __r_arr[0];
-                let __ret: [G; OUT_505] = [__v_21];
-                record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_508] = [__v_21];
+                record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -45352,10 +44795,10 @@ fn aiur_fn_505(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_6, __v_1, __v_2, __v_3]; 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_19: G = __r_arr[0];
-            let __ret: [G; OUT_505] = [__v_19];
-            record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_508] = [__v_19];
+            record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45367,15 +44810,15 @@ fn aiur_fn_505(
   })
 }
 
-const INPUT_SIZE_506: usize = 2;
-const IN_506: usize = 2;
-const OUT_506: usize = 1;
-fn aiur_fn_506(
-  inp: [G; IN_506],
+const INPUT_SIZE_509: usize = 2;
+const IN_509: usize = 2;
+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_506], ExecError> {
+) -> 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];
@@ -45386,20 +44829,20 @@ fn aiur_fn_506(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __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];
         match __v_6.as_canonical_u64() {
           1u64 => {
             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));
+            let __ret: [G; OUT_509] = [__v_7];
+            record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            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 __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_506] = [__v_7];
-            record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_509] = [__v_7];
+            record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45409,23 +44852,23 @@ fn aiur_fn_506(
       },
       _ => {
         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));
+        let __ret: [G; OUT_509] = [__v_6];
+        record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_507: usize = 2;
-const IN_507: usize = 2;
-const OUT_507: usize = 1;
-fn aiur_fn_507(
-  inp: [G; IN_507],
+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_507], ExecError> {
+) -> 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];
@@ -45437,38 +44880,38 @@ fn aiur_fn_507(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_507] = [__v_6];
-        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_510] = [__v_6];
+        record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_507] = [__v_6];
-        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_510] = [__v_6];
+        record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_1, __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 __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_1, __v_3]; 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_507] = [__v_6];
-        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_510] = [__v_6];
+        record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __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];
         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));
+            let __ret: [G; OUT_510] = [__v_7];
+            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_4, __v_1]; 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 __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_7: G = __r_arr[0];
-            let __ret: [G; OUT_507] = [__v_7];
-            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_510] = [__v_7];
+            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45477,20 +44920,20 @@ fn aiur_fn_507(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __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];
         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));
+            let __ret: [G; OUT_510] = [__v_7];
+            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_4, __v_1]; 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 __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_7: G = __r_arr[0];
-            let __ret: [G; OUT_507] = [__v_7];
-            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_510] = [__v_7];
+            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45499,20 +44942,20 @@ fn aiur_fn_507(
         }
       },
       5u64 => {
-        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __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];
         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));
+            let __ret: [G; OUT_510] = [__v_7];
+            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_4, __v_1]; 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 __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_7: G = __r_arr[0];
-            let __ret: [G; OUT_507] = [__v_7];
-            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_510] = [__v_7];
+            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45521,30 +44964,30 @@ fn aiur_fn_507(
         }
       },
       6u64 => {
-        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __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];
         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));
+            let __ret: [G; OUT_510] = [__v_7];
+            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_4, __v_1]; 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 __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_7: G = __r_arr[0];
             match __v_7.as_canonical_u64() {
               1u64 => {
                 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));
+                let __ret: [G; OUT_510] = [__v_8];
+                record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_5, __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_8: G = __r_arr[0];
-                let __ret: [G; OUT_507] = [__v_8];
-                record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_510] = [__v_8];
+                record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -45559,15 +45002,15 @@ fn aiur_fn_507(
       },
       7u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_507] = [__v_6];
-        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_510] = [__v_6];
+        record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_5, __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_507] = [__v_6];
-        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_510] = [__v_6];
+        record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -45577,15 +45020,15 @@ fn aiur_fn_507(
   })
 }
 
-const INPUT_SIZE_508: usize = 2;
-const IN_508: usize = 2;
-const OUT_508: usize = 1;
-fn aiur_fn_508(
-  inp: [G; IN_508],
+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_508], ExecError> {
+) -> 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];
@@ -45596,25 +45039,25 @@ fn aiur_fn_508(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_508] = [__v_5];
-        record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_511] = [__v_5];
+        record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_508] = [__v_6];
-            record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_511] = [__v_6];
+            record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_4, __v_1]; 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 __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_6: G = __r_arr[0];
-            let __ret: [G; OUT_508] = [__v_6];
-            record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_511] = [__v_6];
+            record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45629,37 +45072,37 @@ fn aiur_fn_508(
   })
 }
 
-const INPUT_SIZE_509: usize = 3;
-const IN_509: usize = 3;
-const OUT_509: usize = 1;
-fn aiur_fn_509(
-  inp: [G; IN_509],
+const INPUT_SIZE_512: usize = 3;
+const IN_512: usize = 3;
+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_509], ExecError> {
+) -> 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 = G::from_u64(0);
-    let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_0, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_0, __v_1, __v_2, __v_3]; 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_4: G = __r_arr[0];
-    let __ret: [G; OUT_509] = [__v_4];
-    record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_512] = [__v_4];
+    record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_510: usize = 4;
-const IN_510: usize = 4;
-const OUT_510: usize = 1;
-fn aiur_fn_510(
-  inp: [G; IN_510],
+const INPUT_SIZE_513: usize = 4;
+const IN_513: usize = 4;
+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_510], ExecError> {
+) -> 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];
@@ -45671,8 +45114,8 @@ fn aiur_fn_510(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_510] = [__v_0];
-        record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_513] = [__v_0];
+        record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -45690,7 +45133,7 @@ fn aiur_fn_510(
         let __v_17: G = __loaded[10];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_14, __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 __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
             let __v_19: G = G::from_u64(1);
             let __v_20: G = G::from_u64(0);
@@ -45726,10 +45169,10 @@ fn aiur_fn_510(
             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_126] = { let __args: [G; IN_126] = [__v_1, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1, __v_52]; 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_53: G = __r_arr[0];
             let __v_54: G = (__v_19 - __v_53);
-            let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __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 __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_0, __v_3]; 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_55: G = __r_arr[0];
             let __v_56: G = G::from_u64(1);
             let __v_57: G = (__v_56 - __v_55);
@@ -45741,19 +45184,19 @@ fn aiur_fn_510(
                 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_510] = { let __args: [G; IN_510] = [__v_61, __v_1, __v_6, __v_63]; 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 __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_61, __v_1, __v_6, __v_63]; 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_64: G = __r_arr[0];
-                let __ret: [G; OUT_510] = [__v_64];
-                record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_513] = [__v_64];
+                record.function_queries[513].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_510] = { let __args: [G; IN_510] = [__v_0, __v_1, __v_6, __v_61]; 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 __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_0, __v_1, __v_6, __v_61]; 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_62: G = __r_arr[0];
-                let __ret: [G; OUT_510] = [__v_62];
-                record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_513] = [__v_62];
+                record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -45764,10 +45207,10 @@ fn aiur_fn_510(
           _ => {
             let __v_18: G = G::from_u64(1);
             let __v_19: G = (__v_3 + __v_18);
-            let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_0, __v_1, __v_6, __v_19]; 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 __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_0, __v_1, __v_6, __v_19]; 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_20: G = __r_arr[0];
-            let __ret: [G; OUT_510] = [__v_20];
-            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_513] = [__v_20];
+            record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45779,15 +45222,15 @@ fn aiur_fn_510(
   })
 }
 
-const INPUT_SIZE_511: usize = 5;
-const IN_511: usize = 5;
-const OUT_511: usize = 0;
-fn aiur_fn_511(
-  inp: [G; IN_511],
+const INPUT_SIZE_514: usize = 5;
+const IN_514: usize = 5;
+const OUT_514: usize = 0;
+fn aiur_fn_514(
+  inp: [G; IN_514],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_511], ExecError> {
+) -> Result<[G; OUT_514], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -45800,12 +45243,12 @@ fn aiur_fn_511(
     let __v_7: G = __loaded[2];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_511] = [];
-        record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_514] = [];
+        record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __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];
@@ -45824,19 +45267,19 @@ fn aiur_fn_511(
             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_500] = { let __args: [G; IN_500] = [__v_11, __v_14, __v_22]; 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 __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_11, __v_14, __v_22]; 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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
-            let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_23, __v_2, __v_24, __v_3, __v_4]; 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 __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_511] = [];
-            record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_23, __v_2, __v_24, __v_3, __v_4]; 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 __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_514] = [];
+            record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_511] = [];
-            record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_514] = [];
+            record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45848,15 +45291,15 @@ fn aiur_fn_511(
   })
 }
 
-const INPUT_SIZE_512: usize = 2;
-const IN_512: usize = 2;
-const OUT_512: usize = 1;
-fn aiur_fn_512(
-  inp: [G; IN_512],
+const INPUT_SIZE_515: usize = 2;
+const IN_515: usize = 2;
+const OUT_515: usize = 1;
+fn aiur_fn_515(
+  inp: [G; IN_515],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_512], ExecError> {
+) -> Result<[G; OUT_515], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -45868,14 +45311,14 @@ fn aiur_fn_512(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_512] = [__v_6];
-        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_515] = [__v_6];
+        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_512] = [__v_6];
-        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_515] = [__v_6];
+        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
@@ -45883,77 +45326,77 @@ fn aiur_fn_512(
         match __v_6.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_512] = [__v_7];
-            record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_515] = [__v_7];
+            record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_512] = [__v_7];
-            record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_515] = [__v_7];
+            record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_6, __v_7]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_512] = [__v_8];
-        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_515] = [__v_8];
+        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_6, __v_7]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_512] = [__v_8];
-        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_515] = [__v_8];
+        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_6, __v_7]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_512] = [__v_8];
-        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_515] = [__v_8];
+        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_5, __v_1]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_7, __v_8]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_6, __v_9]; 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_512] = [__v_10];
-        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_515] = [__v_10];
+        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_512] = [__v_6];
-        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_515] = [__v_6];
+        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_5, __v_1]; 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_512] = [__v_6];
-        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_515] = [__v_6];
+        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -45963,44 +45406,44 @@ fn aiur_fn_512(
   })
 }
 
-const INPUT_SIZE_513: usize = 4;
-const IN_513: usize = 4;
-const OUT_513: usize = 1;
-fn aiur_fn_513(
-  inp: [G; IN_513],
+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_513], ExecError> {
+) -> Result<[G; OUT_516], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0]; 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_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_513] = [__v_5];
-        record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_516] = [__v_5];
+        record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; 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];
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_513] = [__v_6];
-            record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_516] = [__v_6];
+            record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_6: G = G::from_u64(0);
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __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];
@@ -46019,18 +45462,18 @@ fn aiur_fn_513(
                 match __v_15.as_canonical_u64() {
                   0u64 => {
                     let __v_20: G = G::from_u64(1);
-                    let __ret: [G; OUT_513] = [__v_20];
-                    record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_516] = [__v_20];
+                    record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
                     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_514] = { let __args: [G; IN_514] = [__v_11, __v_14, __v_15, __v_22, __v_2, __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 __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_11, __v_14, __v_15, __v_22, __v_2, __v_3]; 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_23: G = __r_arr[0];
-                    let __ret: [G; OUT_513] = [__v_23];
-                    record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_516] = [__v_23];
+                    record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -46042,8 +45485,8 @@ fn aiur_fn_513(
           },
           _ => {
             let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_513] = [__v_6];
-            record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_516] = [__v_6];
+            record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46055,15 +45498,15 @@ fn aiur_fn_513(
   })
 }
 
-const INPUT_SIZE_514: usize = 6;
-const IN_514: usize = 6;
-const OUT_514: usize = 1;
-fn aiur_fn_514(
-  inp: [G; IN_514],
+const INPUT_SIZE_517: usize = 6;
+const IN_517: usize = 6;
+const OUT_517: usize = 1;
+fn aiur_fn_517(
+  inp: [G; IN_517],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_514], ExecError> {
+) -> Result<[G; OUT_517], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46077,10 +45520,10 @@ fn aiur_fn_514(
         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_515] = { let __args: [G; IN_515] = [__v_0, __v_2, __v_6, __v_3, __v_4, __v_5, __v_9]; 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 __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_0, __v_2, __v_6, __v_3, __v_4, __v_5, __v_9]; 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_514] = [__v_10];
-        record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_517] = [__v_10];
+        record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46095,16 +45538,16 @@ fn aiur_fn_514(
             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_514] = { let __args: [G; IN_514] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; 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 __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; 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_14: G = __r_arr[0];
-            let __ret: [G; OUT_514] = [__v_14];
-            record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_517] = [__v_14];
+            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_514] = [__v_10];
-            record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_517] = [__v_10];
+            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46113,15 +45556,15 @@ fn aiur_fn_514(
   })
 }
 
-const INPUT_SIZE_515: usize = 7;
-const IN_515: usize = 7;
-const OUT_515: usize = 1;
-fn aiur_fn_515(
-  inp: [G; IN_515],
+const INPUT_SIZE_518: usize = 7;
+const IN_518: usize = 7;
+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_515], ExecError> {
+) -> Result<[G; OUT_518], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46133,13 +45576,13 @@ fn aiur_fn_515(
     let __v_7: G = (__v_1 - __v_2);
     match __v_7.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_6, __v_9]; 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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_6, __v_9]; 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_515] = [__v_10];
-        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_518] = [__v_10];
+        record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46150,13 +45593,13 @@ fn aiur_fn_515(
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_9, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_3, __v_4, __v_5]; 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 __v_13: G = G::from_u64(1);
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
             let __v_16: G = { let __values: [G; 3] = [__v_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_225] = { let __args: [G; IN_225] = [__v_12, __v_16]; 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_12, __v_16]; 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_17: G = __r_arr[0];
             let __v_18: G = (__v_13 - __v_17);
             let __v_19: G = G::from_u64(1);
@@ -46178,16 +45621,16 @@ fn aiur_fn_515(
             let __v_24: G = { let __values: [G; 3] = [__v_23, __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_25: G = G::from_u64(1);
             let __v_26: G = (__v_2 + __v_25);
-            let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_10, __v_1, __v_26, __v_24, __v_4, __v_5, __v_22]; 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 __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_10, __v_1, __v_26, __v_24, __v_4, __v_5, __v_22]; 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_27: G = __r_arr[0];
-            let __ret: [G; OUT_515] = [__v_27];
-            record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_518] = [__v_27];
+            record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(0);
-            let __ret: [G; OUT_515] = [__v_12];
-            record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_518] = [__v_12];
+            record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46196,15 +45639,15 @@ fn aiur_fn_515(
   })
 }
 
-const INPUT_SIZE_516: usize = 2;
-const IN_516: usize = 2;
-const OUT_516: usize = 1;
-fn aiur_fn_516(
-  inp: [G; IN_516],
+const INPUT_SIZE_519: usize = 2;
+const IN_519: usize = 2;
+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_516], ExecError> {
+) -> Result<[G; OUT_519], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46215,25 +45658,25 @@ fn aiur_fn_516(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_516] = [__v_5];
-        record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_519] = [__v_5];
+        record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_1, __v_3]; 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_516] = [__v_6];
-            record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_519] = [__v_6];
+            record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_4, __v_1]; 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_516] = [__v_6];
-            record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_519] = [__v_6];
+            record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46248,15 +45691,15 @@ fn aiur_fn_516(
   })
 }
 
-const INPUT_SIZE_517: usize = 2;
-const IN_517: usize = 2;
-const OUT_517: usize = 1;
-fn aiur_fn_517(
-  inp: [G; IN_517],
+const INPUT_SIZE_520: usize = 2;
+const IN_520: usize = 2;
+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_517], ExecError> {
+) -> Result<[G; OUT_520], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46267,8 +45710,8 @@ fn aiur_fn_517(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_517] = [__v_5];
-        record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_520] = [__v_5];
+        record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -46283,24 +45726,24 @@ fn aiur_fn_517(
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_517] = [__v_10];
-                record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_520] = [__v_10];
+                record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_4, __v_1]; 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 __ret: [G; OUT_517] = [__v_10];
-                record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_520] = [__v_10];
+                record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_4, __v_1]; 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_9: G = __r_arr[0];
-            let __ret: [G; OUT_517] = [__v_9];
-            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_520] = [__v_9];
+            record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46312,15 +45755,15 @@ fn aiur_fn_517(
   })
 }
 
-const INPUT_SIZE_518: usize = 11;
-const IN_518: usize = 11;
-const OUT_518: usize = 1;
-fn aiur_fn_518(
-  inp: [G; IN_518],
+const INPUT_SIZE_521: usize = 11;
+const IN_521: usize = 11;
+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_518], ExecError> {
+) -> Result<[G; OUT_521], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46333,20 +45776,20 @@ fn aiur_fn_518(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_1, __v_4]; 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_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_11, __v_2, __v_6, __v_7, __v_8, __v_12]; 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 __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_11, __v_2, __v_6, __v_7, __v_8, __v_12]; 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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_13, __v_3, __v_9, __v_10]; 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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_13, __v_3, __v_9, __v_10]; 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 __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_519] = { let __args: [G; IN_519] = [__v_17, __v_6, __v_3, __v_7, __v_8]; 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 __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_17, __v_6, __v_3, __v_7, __v_8]; 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_18: G = __r_arr[0];
     let __v_19: G = G::from_u64(0);
-    let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_18, __v_3, __v_19]; 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 __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_18, __v_3, __v_19]; 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_20: G = __r_arr[0];
     let __v_21: G = G::from_u64(1);
     let __v_22: G = G::from_u64(0);
@@ -46354,23 +45797,23 @@ fn aiur_fn_518(
     let __v_24: G = G::from_u64(5);
     let __v_25: G = G::from_u64(0);
     let __v_26: G = { let __values: [G; 4] = [__v_24, __v_20, __v_23, __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 __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_26, __v_14]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_26, __v_14]; 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_27: G = __r_arr[0];
-    let __ret: [G; OUT_518] = [__v_27];
-    record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_521] = [__v_27];
+    record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_519: usize = 5;
-const IN_519: usize = 5;
-const OUT_519: usize = 1;
-fn aiur_fn_519(
-  inp: [G; IN_519],
+const INPUT_SIZE_522: usize = 5;
+const IN_522: usize = 5;
+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_519], ExecError> {
+) -> Result<[G; OUT_522], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46380,32 +45823,32 @@ fn aiur_fn_519(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_0, __v_1, __v_2, __v_5]; 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 __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_519] = [__v_6];
-        record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_522] = [__v_6];
+        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_4, __v_2]; 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 __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_0, __v_4, __v_2]; 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_519] = [__v_5];
-        record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_522] = [__v_5];
+        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_520: usize = 3;
-const IN_520: usize = 3;
-const OUT_520: usize = 1;
-fn aiur_fn_520(
-  inp: [G; IN_520],
+const INPUT_SIZE_523: usize = 3;
+const IN_523: usize = 3;
+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_520], ExecError> {
+) -> Result<[G; OUT_523], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46416,21 +45859,21 @@ fn aiur_fn_520(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_520] = [__v_0];
-        record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_523] = [__v_0];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_2, __v_6]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_2, __v_6]; 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_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_520] = { let __args: [G; IN_520] = [__v_10, __v_5, __v_2]; 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 __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_10, __v_5, __v_2]; 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_520] = [__v_11];
-        record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_523] = [__v_11];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46440,15 +45883,15 @@ fn aiur_fn_520(
   })
 }
 
-const INPUT_SIZE_521: usize = 6;
-const IN_521: usize = 6;
-const OUT_521: usize = 1;
-fn aiur_fn_521(
-  inp: [G; IN_521],
+const INPUT_SIZE_524: usize = 6;
+const IN_524: usize = 6;
+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_521], ExecError> {
+) -> Result<[G; OUT_524], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46458,8 +45901,8 @@ fn aiur_fn_521(
     let __v_5: G = inp[5];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_521] = [__v_0];
-        record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_524] = [__v_0];
+        record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46470,19 +45913,19 @@ fn aiur_fn_521(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_5, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_5, __v_2, __v_3, __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_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_8, __v_10, __v_11]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_8, __v_10, __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 = 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_521] = { let __args: [G; IN_521] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; 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 __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; 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_17: G = __r_arr[0];
-            let __ret: [G; OUT_521] = [__v_17];
-            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_524] = [__v_17];
+            record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46494,15 +45937,15 @@ fn aiur_fn_521(
   })
 }
 
-const INPUT_SIZE_522: usize = 4;
-const IN_522: usize = 4;
-const OUT_522: usize = 1;
-fn aiur_fn_522(
-  inp: [G; IN_522],
+const INPUT_SIZE_525: usize = 4;
+const IN_525: usize = 4;
+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_522], ExecError> {
+) -> Result<[G; OUT_525], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46516,20 +45959,20 @@ fn aiur_fn_522(
         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_522] = [__v_9];
-        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_525] = [__v_9];
+        record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
         let __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_767] = { let __args: [G; IN_767] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_522] = [__v_6];
-            record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_525] = [__v_6];
+            record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46539,8 +45982,8 @@ fn aiur_fn_522(
             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_522] = [__v_11];
-            record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_525] = [__v_11];
+            record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46549,15 +45992,15 @@ fn aiur_fn_522(
   })
 }
 
-const INPUT_SIZE_523: usize = 4;
-const IN_523: usize = 4;
-const OUT_523: usize = 1;
-fn aiur_fn_523(
-  inp: [G; IN_523],
+const INPUT_SIZE_526: usize = 4;
+const IN_526: usize = 4;
+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_523], ExecError> {
+) -> Result<[G; OUT_526], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46565,10 +46008,10 @@ fn aiur_fn_523(
     let __v_3: G = inp[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __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_4: G = __r_arr[0];
-        let __ret: [G; OUT_523] = [__v_4];
-        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_526] = [__v_4];
+        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46576,29 +46019,29 @@ fn aiur_fn_523(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_0, __v_1, __v_4, __v_5, __v_6, __v_3, __v_7]; 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 __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_0, __v_1, __v_4, __v_5, __v_6, __v_3, __v_7]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_523] = [__v_8];
-        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_526] = [__v_8];
+        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_524: usize = 2;
-const IN_524: usize = 2;
-const OUT_524: usize = 1;
-fn aiur_fn_524(
-  inp: [G; IN_524],
+const INPUT_SIZE_527: usize = 2;
+const IN_527: usize = 2;
+const OUT_527: usize = 1;
+fn aiur_fn_527(
+  inp: [G; IN_527],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_524], ExecError> {
+) -> Result<[G; OUT_527], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_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];
@@ -46614,29 +46057,29 @@ fn aiur_fn_524(
     let __v_13: G = __loaded[10];
     match __v_3.as_canonical_u64() {
       6u64 => {
-        let __ret: [G; OUT_524] = [__v_8];
-        record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_527] = [__v_8];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_524] = [__v_14];
-        record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_527] = [__v_14];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_525: usize = 7;
-const IN_525: usize = 7;
-const OUT_525: usize = 1;
-fn aiur_fn_525(
-  inp: [G; IN_525],
+const INPUT_SIZE_528: usize = 7;
+const IN_528: usize = 7;
+const OUT_528: usize = 1;
+fn aiur_fn_528(
+  inp: [G; IN_528],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_525], ExecError> {
+) -> Result<[G; OUT_528], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46647,8 +46090,8 @@ fn aiur_fn_525(
     let __v_6: G = inp[6];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_525] = [__v_0];
-        record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_528] = [__v_0];
+        record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46659,19 +46102,19 @@ fn aiur_fn_525(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_6, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_6, __v_2, __v_3, __v_4, __v_5]; 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_11: G = __r_arr[0];
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_9, __v_11, __v_12]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_9, __v_11, __v_12]; 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_13: G = __r_arr[0];
             let __v_14: G = G::from_u64(1);
             let __v_15: G = (__v_1 - __v_14);
             let __v_16: G = G::from_u64(1);
             let __v_17: G = (__v_6 + __v_16);
-            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; 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 __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; 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_18: G = __r_arr[0];
-            let __ret: [G; OUT_525] = [__v_18];
-            record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_528] = [__v_18];
+            record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46683,15 +46126,15 @@ fn aiur_fn_525(
   })
 }
 
-const INPUT_SIZE_526: usize = 5;
-const IN_526: usize = 5;
-const OUT_526: usize = 1;
-fn aiur_fn_526(
-  inp: [G; IN_526],
+const INPUT_SIZE_529: usize = 5;
+const IN_529: usize = 5;
+const OUT_529: usize = 1;
+fn aiur_fn_529(
+  inp: [G; IN_529],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_526], ExecError> {
+) -> Result<[G; OUT_529], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46706,23 +46149,23 @@ fn aiur_fn_526(
         let __v_8: G = (__v_7 - __v_0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_526] = [__v_10];
-        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_529] = [__v_10];
+        record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_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 __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_7, __v_2, __v_8]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_7, __v_2, __v_8]; 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 __ret: [G; OUT_526] = [__v_9];
-            record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_529] = [__v_9];
+            record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46732,8 +46175,8 @@ fn aiur_fn_526(
             let __v_10: G = (__v_9 - __v_0);
             let __v_11: G = G::from_u64(0);
             let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_526] = [__v_12];
-            record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_529] = [__v_12];
+            record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46742,15 +46185,15 @@ fn aiur_fn_526(
   })
 }
 
-const INPUT_SIZE_527: usize = 4;
-const IN_527: usize = 4;
-const OUT_527: usize = 1;
-fn aiur_fn_527(
-  inp: [G; IN_527],
+const INPUT_SIZE_530: usize = 4;
+const IN_530: usize = 4;
+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_527], ExecError> {
+) -> 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];
@@ -46761,15 +46204,15 @@ fn aiur_fn_527(
         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_527] = [__v_6];
-        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_530] = [__v_6];
+        record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(1);
         let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_6, __v_2, __v_3]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_6, __v_2, __v_3]; 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_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];
@@ -46781,11 +46224,11 @@ fn aiur_fn_527(
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(1);
             let __v_14: G = (__v_1 - __v_13);
-            let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_10, __v_14, __v_2, __v_3]; 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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_10, __v_14, __v_2, __v_3]; 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_15: G = __r_arr[0];
             let __v_16: G = { let __values: [G; 3] = [__v_12, __v_9, __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_527] = [__v_16];
-            record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_530] = [__v_16];
+            record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46797,15 +46240,15 @@ fn aiur_fn_527(
   })
 }
 
-const INPUT_SIZE_528: usize = 3;
-const IN_528: usize = 3;
-const OUT_528: usize = 1;
-fn aiur_fn_528(
-  inp: [G; IN_528],
+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_528], ExecError> {
+) -> Result<[G; OUT_531], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46816,8 +46259,8 @@ fn aiur_fn_528(
         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_528] = [__v_6];
-        record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_531] = [__v_6];
+        record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46828,26 +46271,26 @@ fn aiur_fn_528(
         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_528] = { let __args: [G; IN_528] = [__v_0, __v_1, __v_10]; 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 __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_1, __v_10]; 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_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_528] = [__v_12];
-        record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_531] = [__v_12];
+        record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_529: usize = 4;
-const IN_529: usize = 4;
-const OUT_529: usize = 1;
-fn aiur_fn_529(
-  inp: [G; IN_529],
+const INPUT_SIZE_532: usize = 4;
+const IN_532: usize = 4;
+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_529], ExecError> {
+) -> Result<[G; OUT_532], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46856,8 +46299,8 @@ fn aiur_fn_529(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_529] = [__v_0];
-        record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_532] = [__v_0];
+        record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46873,25 +46316,25 @@ fn aiur_fn_529(
         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_529] = { let __args: [G; IN_529] = [__v_14, __v_1, __v_2, __v_16]; 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 __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
-        let __ret: [G; OUT_529] = [__v_17];
-        record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_532] = [__v_17];
+        record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_530: usize = 3;
-const IN_530: usize = 3;
-const OUT_530: usize = 1;
-fn aiur_fn_530(
-  inp: [G; IN_530],
+const INPUT_SIZE_533: usize = 3;
+const IN_533: usize = 3;
+const OUT_533: usize = 1;
+fn aiur_fn_533(
+  inp: [G; IN_533],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_530], ExecError> {
+) -> Result<[G; OUT_533], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46899,8 +46342,8 @@ fn aiur_fn_530(
     let __v_3: G = (__v_1 - __v_2);
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_530] = [__v_0];
-        record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_533] = [__v_0];
+        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46915,25 +46358,25 @@ fn aiur_fn_530(
         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_530] = { let __args: [G; IN_530] = [__v_12, __v_1, __v_14]; 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 __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_12, __v_1, __v_14]; 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_15: G = __r_arr[0];
-        let __ret: [G; OUT_530] = [__v_15];
-        record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_533] = [__v_15];
+        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_531: usize = 2;
-const IN_531: usize = 2;
-const OUT_531: usize = 1;
-fn aiur_fn_531(
-  inp: [G; IN_531],
+const INPUT_SIZE_534: usize = 2;
+const IN_534: usize = 2;
+const OUT_534: usize = 1;
+fn aiur_fn_534(
+  inp: [G; IN_534],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_531], ExecError> {
+) -> Result<[G; OUT_534], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46943,18 +46386,18 @@ fn aiur_fn_531(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_531] = [__v_0];
-        record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_534] = [__v_0];
+        record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(5);
-        let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0, __v_4]; 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_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_531] = [__v_8];
-        record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_534] = [__v_8];
+        record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46964,15 +46407,15 @@ fn aiur_fn_531(
   })
 }
 
-const INPUT_SIZE_532: usize = 16;
-const IN_532: usize = 16;
-const OUT_532: usize = 1;
-fn aiur_fn_532(
-  inp: [G; IN_532],
+const INPUT_SIZE_535: usize = 16;
+const IN_535: usize = 16;
+const OUT_535: usize = 1;
+fn aiur_fn_535(
+  inp: [G; IN_535],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_532], ExecError> {
+) -> Result<[G; OUT_535], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46990,15 +46433,15 @@ fn aiur_fn_532(
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_2, __v_5]; 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_2, __v_5]; 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_16: G = __r_arr[0];
     let __v_17: G = (__v_10 + __v_11);
     let __v_18: G = (__v_9 + __v_17);
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__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 __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_14]; 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_19: G = __r_arr[0];
     let __v_20: G = (__v_10 + __v_11);
     let __v_21: G = G::from_u64(0);
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_16, __v_19, __v_18, __v_20, __v_3, __v_4, __v_21]; 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 __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_16, __v_19, __v_18, __v_20, __v_3, __v_4, __v_21]; 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_22: G = __r_arr[0];
     let __v_23: G = G::from_u64(1);
     let __v_24: G = G::from_u64(1);
@@ -47013,24 +46456,24 @@ fn aiur_fn_532(
     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_535] = { let __args: [G; IN_535] = [__v_22, __v_6, __v_25, __v_28, __v_31, __v_34, __v_14, __v_15, __v_35, __v_20]; 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 __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_22, __v_6, __v_25, __v_28, __v_31, __v_34, __v_14, __v_15, __v_35, __v_20]; 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_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_196] = { let __args: [G; IN_196] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_36]; 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_40: G = __r_arr[0];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
     let __v_41: G = __r_arr[0];
     let __v_42: G = (__v_40 + __v_41);
     let __v_43: G = (__v_18 + __v_42);
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_39]; 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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_39]; 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_44: G = __r_arr[0];
     let __v_45: G = __r_arr[1];
-    let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_45, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_45, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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_548] = { let __args: [G; IN_548] = [__v_46, __v_41, __v_47]; 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 __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_46, __v_41, __v_47]; 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_48: G = __r_arr[0];
     let __v_49: G = G::from_u64(1);
     let __v_50: G = (__v_43 - __v_49);
@@ -47039,15 +46482,15 @@ fn aiur_fn_532(
     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_404] = { let __args: [G; IN_404] = [__v_55, __v_48]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_55, __v_48]; 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_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_533] = { let __args: [G; IN_533] = [__v_59, __v_19, __v_9, __v_43, __v_3, __v_4]; 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 __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_59, __v_19, __v_9, __v_43, __v_3, __v_4]; 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_60: G = __r_arr[0];
     let __v_61: G = G::from_u64(0);
-    let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_60, __v_40, __v_42, __v_61]; 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 __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_60, __v_40, __v_42, __v_61]; 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_62: G = __r_arr[0];
     let __v_63: G = G::from_u64(3);
     let __v_64: G = G::from_u64(0);
@@ -47056,27 +46499,27 @@ fn aiur_fn_532(
     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_626] = { let __args: [G; IN_626] = [__v_37, __v_38, __v_36, __v_8, __v_12, __v_40, __v_18, __v_68, __v_14, __v_15, __v_69]; 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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_37, __v_38, __v_36, __v_8, __v_12, __v_40, __v_18, __v_68, __v_14, __v_15, __v_69]; 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 __v_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_65, __v_70]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_65, __v_70]; 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_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_71, __v_36]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_71, __v_36]; 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_72: G = __r_arr[0];
-    let __ret: [G; OUT_532] = [__v_72];
-    record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_535] = [__v_72];
+    record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_533: usize = 6;
-const IN_533: usize = 6;
-const OUT_533: usize = 1;
-fn aiur_fn_533(
-  inp: [G; IN_533],
+const INPUT_SIZE_536: usize = 6;
+const IN_536: usize = 6;
+const OUT_536: usize = 1;
+fn aiur_fn_536(
+  inp: [G; IN_536],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_533], ExecError> {
+) -> Result<[G; OUT_536], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47089,33 +46532,33 @@ fn aiur_fn_533(
         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_549] = { let __args: [G; IN_549] = [__v_0, __v_2, __v_7, __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 __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_2, __v_7, __v_8]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_533] = [__v_9];
-        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_536] = [__v_9];
+        record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = (__v_3 - __v_2);
-        let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_5, __v_6]; 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 __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_0, __v_5, __v_6]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_533] = [__v_7];
-        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_536] = [__v_7];
+        record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_534: usize = 4;
-const IN_534: usize = 4;
-const OUT_534: usize = 1;
-fn aiur_fn_534(
-  inp: [G; IN_534],
+const INPUT_SIZE_537: usize = 4;
+const IN_537: usize = 4;
+const OUT_537: usize = 1;
+fn aiur_fn_537(
+  inp: [G; IN_537],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_534], ExecError> {
+) -> Result<[G; OUT_537], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47123,8 +46566,8 @@ fn aiur_fn_534(
     let __v_3: G = inp[3];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_534] = [__v_0];
-        record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_537] = [__v_0];
+        record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -47142,16 +46585,16 @@ fn aiur_fn_534(
             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_399] = { let __args: [G; IN_399] = [__v_6, __v_13, __v_14]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_6, __v_13, __v_14]; 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_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_534] = { let __args: [G; IN_534] = [__v_15, __v_17, __v_2, __v_19]; 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 __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_15, __v_17, __v_2, __v_19]; 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_20: G = __r_arr[0];
-            let __ret: [G; OUT_534] = [__v_20];
-            record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_537] = [__v_20];
+            record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -47163,15 +46606,15 @@ fn aiur_fn_534(
   })
 }
 
-const INPUT_SIZE_535: usize = 10;
-const IN_535: usize = 10;
-const OUT_535: usize = 4;
-fn aiur_fn_535(
-  inp: [G; IN_535],
+const INPUT_SIZE_538: usize = 10;
+const IN_538: usize = 10;
+const OUT_538: usize = 4;
+fn aiur_fn_538(
+  inp: [G; IN_538],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_535], ExecError> {
+) -> Result<[G; OUT_538], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47190,7 +46633,7 @@ fn aiur_fn_535(
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_11, __v_1, __v_5, __v_6, __v_7, __v_9]; 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 __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_11, __v_1, __v_5, __v_6, __v_7, __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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         let __v_16: G = G::from_u64(0);
@@ -47205,57 +46648,57 @@ fn aiur_fn_535(
             let __v_23: G = { let __values: [G; 3] = [__v_22, __v_15, __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_24: G = G::from_u64(1);
             let __v_25: G = (__v_8 + __v_24);
-            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_12, __v_1, __v_17, __v_21, __v_23, __v_19, __v_6, __v_7, __v_25, __v_9]; 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 __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_12, __v_1, __v_17, __v_21, __v_23, __v_19, __v_6, __v_7, __v_25, __v_9]; 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_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 __ret: [G; OUT_535] = [__v_26, __v_27, __v_28, __v_29];
-            record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_538] = [__v_26, __v_27, __v_28, __v_29];
+            record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_20: G = G::from_u64(1);
             let __v_21: G = (__v_8 + __v_20);
-            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_12, __v_1, __v_17, __v_3, __v_4, __v_19, __v_6, __v_7, __v_21, __v_9]; 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 __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_12, __v_1, __v_17, __v_3, __v_4, __v_19, __v_6, __v_7, __v_21, __v_9]; 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_22: G = __r_arr[0];
             let __v_23: G = __r_arr[1];
             let __v_24: G = __r_arr[2];
             let __v_25: G = __r_arr[3];
-            let __ret: [G; OUT_535] = [__v_22, __v_23, __v_24, __v_25];
-            record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_538] = [__v_22, __v_23, __v_24, __v_25];
+            record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_535] = [__v_14, __v_15, __v_16, __v_0];
-        record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_538] = [__v_14, __v_15, __v_16, __v_0];
+        record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_536: usize = 2;
-const IN_536: usize = 2;
-const OUT_536: usize = 1;
-fn aiur_fn_536(
-  inp: [G; IN_536],
+const INPUT_SIZE_539: usize = 2;
+const IN_539: usize = 2;
+const OUT_539: usize = 1;
+fn aiur_fn_539(
+  inp: [G; IN_539],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_536], ExecError> {
+) -> Result<[G; OUT_539], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_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];
@@ -47304,7 +46747,7 @@ fn aiur_fn_536(
         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_126] = { let __args: [G; IN_126] = [__v_10, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_10, __v_46]; 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_47: G = __r_arr[0];
         match __v_47.as_canonical_u64() {
           1u64 => {
@@ -47313,30 +46756,30 @@ fn aiur_fn_536(
             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_536] = [__v_52];
-            record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_539] = [__v_52];
+            record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_48: G = G::from_u64(0);
-            let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_48]; 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 __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_1, __v_48]; 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_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 __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
             let __v_55: G = __r_arr[0];
             let __v_56: G = G::from_u64(1);
             let __v_57: G = G::from_u64(1);
             let __v_58: G = { let __values: [G; 4] = [__v_56, __v_57, __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 __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_55, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_55, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
             let __v_59: G = __r_arr[0];
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_59, __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 __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_59, __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_60: G = __r_arr[0];
-            let __ret: [G; OUT_536] = [__v_60];
-            record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_539] = [__v_60];
+            record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -47350,23 +46793,23 @@ fn aiur_fn_536(
         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_536] = [__v_18];
-        record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_539] = [__v_18];
+        record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_537: usize = 2;
-const IN_537: usize = 2;
-const OUT_537: usize = 6;
-fn aiur_fn_537(
-  inp: [G; IN_537],
+const INPUT_SIZE_540: usize = 2;
+const IN_540: usize = 2;
+const OUT_540: usize = 6;
+fn aiur_fn_540(
+  inp: [G; IN_540],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_537], ExecError> {
+) -> Result<[G; OUT_540], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47378,8 +46821,8 @@ fn aiur_fn_537(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_537] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6];
-        record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_540] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6];
+        record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -47397,7 +46840,7 @@ fn aiur_fn_537(
         let __v_15: G = __loaded[10];
         let __v_16: G = G::from_u64(1);
         let __v_17: G = (__v_1 + __v_16);
-        let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_4, __v_17]; 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 __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_4, __v_17]; 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 __v_20: G = __r_arr[2];
@@ -47439,24 +46882,24 @@ fn aiur_fn_537(
             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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_12, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_12, __v_56]; 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_57: G = __r_arr[0];
             match __v_57.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_537] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-                record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_540] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+                record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_12, __v_1]; 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 __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_12, __v_1]; 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_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 __ret: [G; OUT_537] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-                record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_540] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
+                record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -47465,8 +46908,8 @@ fn aiur_fn_537(
             }
           },
           _ => {
-            let __ret: [G; OUT_537] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-            record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_540] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+            record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -47478,15 +46921,15 @@ fn aiur_fn_537(
   })
 }
 
-const INPUT_SIZE_538: usize = 8;
-const IN_538: usize = 8;
-const OUT_538: usize = 6;
-fn aiur_fn_538(
-  inp: [G; IN_538],
+const INPUT_SIZE_541: usize = 8;
+const IN_541: usize = 8;
+const OUT_541: usize = 6;
+fn aiur_fn_541(
+  inp: [G; IN_541],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_538], ExecError> {
+) -> Result<[G; OUT_541], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47496,37 +46939,37 @@ fn aiur_fn_538(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __v_9: G = G::from_u64(1);
     let __v_10: G = G::from_u64(1);
     let __v_11: G = { let __values: [G; 4] = [__v_9, __v_10, __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 __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_12, __v_6, __v_7]; 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 __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_12, __v_6, __v_7]; 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 __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_13, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __v_13, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_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 __ret: [G; OUT_538] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-    record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_541] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+    record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_539: usize = 3;
-const IN_539: usize = 3;
-const OUT_539: usize = 1;
-fn aiur_fn_539(
-  inp: [G; IN_539],
+const INPUT_SIZE_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_539], ExecError> {
+) -> Result<[G; OUT_542], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47548,12 +46991,12 @@ fn aiur_fn_539(
         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 __v_16: G = { let __values: [G; 4] = [__v_7, __v_1, __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_539] = [__v_16];
-        record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_542] = [__v_16];
+        record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_4, __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 __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
@@ -47561,17 +47004,17 @@ fn aiur_fn_539(
             let __v_9: G = G::from_u64(0);
             let __v_10: G = { let __values: [G; 3] = [__v_9, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_11: G = { let __values: [G; 4] = [__v_8, __v_4, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_539] = [__v_11];
-            record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_542] = [__v_11];
+            record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_6, __v_1, __v_2]; 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 __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_6, __v_1, __v_2]; 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_9: G = __r_arr[0];
             let __v_10: G = { let __values: [G; 4] = [__v_8, __v_4, __v_5, __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_539] = [__v_10];
-            record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_542] = [__v_10];
+            record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -47586,15 +47029,15 @@ fn aiur_fn_539(
   })
 }
 
-const INPUT_SIZE_540: usize = 2;
-const IN_540: usize = 2;
-const OUT_540: usize = 1;
-fn aiur_fn_540(
-  inp: [G; IN_540],
+const INPUT_SIZE_543: usize = 2;
+const IN_543: usize = 2;
+const OUT_543: usize = 1;
+fn aiur_fn_543(
+  inp: [G; IN_543],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_540], ExecError> {
+) -> Result<[G; OUT_543], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47608,24 +47051,24 @@ fn aiur_fn_540(
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_540] = [__v_8];
-        record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_543] = [__v_8];
+        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __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 __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_540] = [__v_4];
-            record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_543] = [__v_4];
+            record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_5, __v_1]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_540] = [__v_7];
-            record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_543] = [__v_7];
+            record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -47640,20 +47083,20 @@ fn aiur_fn_540(
   })
 }
 
-const INPUT_SIZE_541: usize = 3;
-const IN_541: usize = 3;
-const OUT_541: usize = 1;
-fn aiur_fn_541(
-  inp: [G; IN_541],
+const INPUT_SIZE_544: usize = 3;
+const IN_544: usize = 3;
+const OUT_544: usize = 1;
+fn aiur_fn_544(
+  inp: [G; IN_544],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_541], ExecError> {
+) -> Result<[G; OUT_544], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __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];
@@ -47702,17 +47145,17 @@ fn aiur_fn_541(
         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_126] = { let __args: [G; IN_126] = [__v_11, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_11, __v_47]; 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_48: G = __r_arr[0];
         match __v_48.as_canonical_u64() {
           1u64 => {
             let __v_49: G = G::from_u64(0);
-            let __ret: [G; OUT_541] = [__v_49];
-            record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_544] = [__v_49];
+            record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_49: G = __r_arr[0];
             let __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];
@@ -47728,16 +47171,16 @@ fn aiur_fn_541(
             let __v_60: G = __loaded[10];
             match __v_50.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_57, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_57, __v_11]; 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_61: G = __r_arr[0];
-                let __ret: [G; OUT_541] = [__v_61];
-                record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_544] = [__v_61];
+                record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_61: G = G::from_u64(0);
-                let __ret: [G; OUT_541] = [__v_61];
-                record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_544] = [__v_61];
+                record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -47749,23 +47192,23 @@ fn aiur_fn_541(
       },
       _ => {
         let __v_15: G = G::from_u64(0);
-        let __ret: [G; OUT_541] = [__v_15];
-        record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_544] = [__v_15];
+        record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_542: usize = 6;
-const IN_542: usize = 6;
-const OUT_542: usize = 2;
-fn aiur_fn_542(
-  inp: [G; IN_542],
+const INPUT_SIZE_545: usize = 6;
+const IN_545: usize = 6;
+const OUT_545: usize = 2;
+fn aiur_fn_545(
+  inp: [G; IN_545],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_542], ExecError> {
+) -> Result<[G; OUT_545], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47773,16 +47216,16 @@ fn aiur_fn_542(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0]; 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 __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
-    let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_7, __v_9, __v_3, __v_4]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_7, __v_9, __v_3, __v_4]; 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_10: G = __r_arr[0];
-    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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !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_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 };
@@ -47792,37 +47235,37 @@ fn aiur_fn_542(
     let __v_16: G = __loaded[3];
     match __v_13.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2]; 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_17: G = __r_arr[0];
         let __v_18: G = (__v_5 + __v_17);
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_1, __v_14, __v_12, __v_19, __v_18]; 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 __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_14, __v_12, __v_19, __v_18]; 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
-        let __ret: [G; OUT_542] = [__v_20, __v_21];
-        record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_545] = [__v_20, __v_21];
+        record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_17: G = G::from_u64(0);
         let __v_18: G = G::from_u64(0);
-        let __ret: [G; OUT_542] = [__v_17, __v_18];
-        record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_545] = [__v_17, __v_18];
+        record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_543: usize = 5;
-const IN_543: usize = 5;
-const OUT_543: usize = 2;
-fn aiur_fn_543(
-  inp: [G; IN_543],
+const INPUT_SIZE_546: usize = 5;
+const IN_546: usize = 5;
+const OUT_546: usize = 2;
+fn aiur_fn_546(
+  inp: [G; IN_546],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_543], ExecError> {
+) -> Result<[G; OUT_546], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47840,31 +47283,31 @@ fn aiur_fn_543(
       1u64 => {
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_543] = [__v_11, __v_12];
-        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_546] = [__v_11, __v_12];
+        record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_11: G = (__v_6 - __v_1);
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_2, __v_8, __v_4]; 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 __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_2, __v_8, __v_4]; 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_12: G = __r_arr[0];
             match __v_12.as_canonical_u64() {
               1u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __ret: [G; OUT_543] = [__v_13, __v_3];
-                record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_546] = [__v_13, __v_3];
+                record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(1);
                 let __v_14: G = (__v_3 + __v_13);
-                let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_10, __v_1, __v_2, __v_14, __v_4]; 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 __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_10, __v_1, __v_2, __v_14, __v_4]; 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_15: G = __r_arr[0];
                 let __v_16: G = __r_arr[1];
-                let __ret: [G; OUT_543] = [__v_15, __v_16];
-                record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_546] = [__v_15, __v_16];
+                record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -47872,11 +47315,11 @@ fn aiur_fn_543(
           _ => {
             let __v_12: G = G::from_u64(1);
             let __v_13: G = (__v_3 + __v_12);
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_10, __v_1, __v_2, __v_13, __v_4]; 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 __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_10, __v_1, __v_2, __v_13, __v_4]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_543] = [__v_14, __v_15];
-            record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_546] = [__v_14, __v_15];
+            record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -47888,15 +47331,15 @@ fn aiur_fn_543(
   })
 }
 
-const INPUT_SIZE_544: usize = 3;
-const IN_544: usize = 3;
-const OUT_544: usize = 1;
-fn aiur_fn_544(
-  inp: [G; IN_544],
+const INPUT_SIZE_547: usize = 3;
+const IN_547: usize = 3;
+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_544], ExecError> {
+) -> Result<[G; OUT_547], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47908,8 +47351,8 @@ fn aiur_fn_544(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_544] = [__v_6];
-        record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_547] = [__v_6];
+        record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -47920,28 +47363,28 @@ fn aiur_fn_544(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_544] = [__v_9];
-            record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_547] = [__v_9];
+            record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_2, __v_9]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __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 __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_7, __v_10]; 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 __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_7, __v_10]; 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_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_8, __v_5, __v_2]; 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 __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_8, __v_5, __v_2]; 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_12: G = __r_arr[0];
-                let __ret: [G; OUT_544] = [__v_12];
-                record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_547] = [__v_12];
+                record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_544] = [__v_12];
-                record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_547] = [__v_12];
+                record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -47958,15 +47401,15 @@ fn aiur_fn_544(
   })
 }
 
-const INPUT_SIZE_545: usize = 3;
-const IN_545: usize = 3;
-const OUT_545: usize = 2;
-fn aiur_fn_545(
-  inp: [G; IN_545],
+const INPUT_SIZE_548: usize = 3;
+const IN_548: usize = 3;
+const OUT_548: usize = 2;
+fn aiur_fn_548(
+  inp: [G; IN_548],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_545], ExecError> {
+) -> Result<[G; OUT_548], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47979,8 +47422,8 @@ fn aiur_fn_545(
       1u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_545] = [__v_6, __v_7];
-        record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_548] = [__v_6, __v_7];
+        record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -47988,18 +47431,18 @@ fn aiur_fn_545(
         match __v_6.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_545] = [__v_7, __v_2];
-            record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_548] = [__v_7, __v_2];
+            record.function_queries[548].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_545] = { let __args: [G; IN_545] = [__v_5, __v_1, __v_8]; 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 __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_5, __v_1, __v_8]; 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_545] = [__v_9, __v_10];
-            record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_548] = [__v_9, __v_10];
+            record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -48011,40 +47454,40 @@ fn aiur_fn_545(
   })
 }
 
-const INPUT_SIZE_546: usize = 1;
-const IN_546: usize = 1;
-const OUT_546: usize = 2;
-fn aiur_fn_546(
-  inp: [G; IN_546],
+const INPUT_SIZE_549: usize = 1;
+const IN_549: usize = 1;
+const OUT_549: usize = 2;
+fn aiur_fn_549(
+  inp: [G; IN_549],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_546], ExecError> {
+) -> Result<[G; OUT_549], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = 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_547] = { let __args: [G; IN_547] = [__v_0, __v_3]; 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 __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_3]; 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_546] = [__v_6, __v_5];
-    record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_549] = [__v_6, __v_5];
+    record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_547: usize = 2;
-const IN_547: usize = 2;
-const OUT_547: usize = 2;
-fn aiur_fn_547(
-  inp: [G; IN_547],
+const INPUT_SIZE_550: usize = 2;
+const IN_550: usize = 2;
+const OUT_550: usize = 2;
+fn aiur_fn_550(
+  inp: [G; IN_550],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_547], ExecError> {
+) -> Result<[G; OUT_550], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48057,31 +47500,31 @@ fn aiur_fn_547(
       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_547] = { let __args: [G; IN_547] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_4, __v_7]; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_547] = [__v_8, __v_9];
-        record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_550] = [__v_8, __v_9];
+        record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_547] = [__v_1, __v_0];
-        record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_550] = [__v_1, __v_0];
+        record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_548: usize = 3;
-const IN_548: usize = 3;
-const OUT_548: usize = 1;
-fn aiur_fn_548(
-  inp: [G; IN_548],
+const INPUT_SIZE_551: usize = 3;
+const IN_551: usize = 3;
+const OUT_551: usize = 1;
+fn aiur_fn_551(
+  inp: [G; IN_551],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_548], ExecError> {
+) -> Result<[G; OUT_551], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48095,19 +47538,19 @@ fn aiur_fn_548(
         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_548] = [__v_8];
-        record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_551] = [__v_8];
+        record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __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 __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_5, __v_1, __v_2]; 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_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_548] = [__v_9];
-        record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_551] = [__v_9];
+        record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48117,15 +47560,15 @@ fn aiur_fn_548(
   })
 }
 
-const INPUT_SIZE_549: usize = 4;
-const IN_549: usize = 4;
-const OUT_549: usize = 1;
-fn aiur_fn_549(
-  inp: [G; IN_549],
+const INPUT_SIZE_552: usize = 4;
+const IN_552: usize = 4;
+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_549], ExecError> {
+) -> Result<[G; OUT_552], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48134,8 +47577,8 @@ fn aiur_fn_549(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_549] = [__v_0];
-        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_552] = [__v_0];
+        record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48148,25 +47591,25 @@ fn aiur_fn_549(
         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_549] = { let __args: [G; IN_549] = [__v_11, __v_1, __v_2, __v_13]; 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 __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_11, __v_1, __v_2, __v_13]; 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 __ret: [G; OUT_549] = [__v_14];
-        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_552] = [__v_14];
+        record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_550: usize = 4;
-const IN_550: usize = 4;
-const OUT_550: usize = 1;
-fn aiur_fn_550(
-  inp: [G; IN_550],
+const INPUT_SIZE_553: usize = 4;
+const IN_553: usize = 4;
+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_550], ExecError> {
+) -> Result<[G; OUT_553], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48175,8 +47618,8 @@ fn aiur_fn_550(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_550] = [__v_0];
-        record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_553] = [__v_0];
+        record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48191,59 +47634,59 @@ fn aiur_fn_550(
         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_550] = { let __args: [G; IN_550] = [__v_13, __v_1, __v_2, __v_15]; 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 __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_13, __v_1, __v_2, __v_15]; 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_16: G = __r_arr[0];
-        let __ret: [G; OUT_550] = [__v_16];
-        record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_553] = [__v_16];
+        record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_551: usize = 2;
-const IN_551: usize = 2;
-const OUT_551: usize = 2;
-fn aiur_fn_551(
-  inp: [G; IN_551],
+const INPUT_SIZE_554: usize = 2;
+const IN_554: usize = 2;
+const OUT_554: usize = 2;
+fn aiur_fn_554(
+  inp: [G; IN_554],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_551], ExecError> {
+) -> Result<[G; OUT_554], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = 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_552] = { let __args: [G; IN_552] = [__v_0, __v_1, __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 __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __ret: [G; OUT_551] = [__v_7, __v_6];
-    record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_554] = [__v_7, __v_6];
+    record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_552: usize = 3;
-const IN_552: usize = 3;
-const OUT_552: usize = 2;
-fn aiur_fn_552(
-  inp: [G; IN_552],
+const INPUT_SIZE_555: usize = 3;
+const IN_555: usize = 3;
+const OUT_555: usize = 2;
+fn aiur_fn_555(
+  inp: [G; IN_555],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_552], ExecError> {
+) -> Result<[G; OUT_555], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_552] = [__v_2, __v_0];
-        record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_555] = [__v_2, __v_0];
+        record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48258,11 +47701,11 @@ fn aiur_fn_552(
             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_552] = { let __args: [G; IN_552] = [__v_5, __v_8, __v_10]; 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 __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_5, __v_8, __v_10]; 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_552] = [__v_11, __v_12];
-            record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_555] = [__v_11, __v_12];
+            record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -48274,15 +47717,15 @@ fn aiur_fn_552(
   })
 }
 
-const INPUT_SIZE_553: usize = 3;
-const IN_553: usize = 3;
-const OUT_553: usize = 1;
-fn aiur_fn_553(
-  inp: [G; IN_553],
+const INPUT_SIZE_556: usize = 3;
+const IN_556: usize = 3;
+const OUT_556: usize = 1;
+fn aiur_fn_556(
+  inp: [G; IN_556],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_553], ExecError> {
+) -> Result<[G; OUT_556], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48290,8 +47733,8 @@ fn aiur_fn_553(
     let __v_3: G = (__v_1 - __v_2);
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_553] = [__v_0];
-        record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_556] = [__v_0];
+        record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48304,25 +47747,25 @@ fn aiur_fn_553(
         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_553] = { let __args: [G; IN_553] = [__v_10, __v_1, __v_12]; 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 __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_553] = [__v_13];
-        record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_556] = [__v_13];
+        record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_554: usize = 15;
-const IN_554: usize = 15;
-const OUT_554: usize = 1;
-fn aiur_fn_554(
-  inp: [G; IN_554],
+const INPUT_SIZE_557: usize = 15;
+const IN_557: usize = 15;
+const OUT_557: usize = 1;
+fn aiur_fn_557(
+  inp: [G; IN_557],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_554], ExecError> {
+) -> Result<[G; OUT_557], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48348,12 +47791,12 @@ fn aiur_fn_554(
         let __v_18: G = G::from_u64(1);
         let __v_19: G = G::from_u64(1);
         let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_554] = [__v_20];
-        record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_557] = [__v_20];
+        record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -48369,16 +47812,16 @@ fn aiur_fn_554(
         let __v_29: G = __loaded[10];
         match __v_19.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_1, __v_16, __v_21, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_14, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_1, __v_16, __v_21, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_14, __v_10, __v_11, __v_12, __v_13]; 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_30: G = __r_arr[0];
             let __v_31: G = G::from_u64(1);
             let __v_32: G = (__v_14 + __v_31);
-            let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_32]; 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 __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_32]; 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_33: G = __r_arr[0];
             let __v_34: G = G::from_u64(0);
             let __v_35: G = { let __values: [G; 3] = [__v_34, __v_30, __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 __ret: [G; OUT_554] = [__v_35];
-            record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_557] = [__v_35];
+            record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -48393,15 +47836,15 @@ fn aiur_fn_554(
   })
 }
 
-const INPUT_SIZE_555: usize = 8;
-const IN_555: usize = 8;
-const OUT_555: usize = 1;
-fn aiur_fn_555(
-  inp: [G; IN_555],
+const INPUT_SIZE_558: usize = 8;
+const IN_558: usize = 8;
+const OUT_558: usize = 1;
+fn aiur_fn_558(
+  inp: [G; IN_558],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_555], ExecError> {
+) -> Result<[G; OUT_558], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48412,23 +47855,23 @@ fn aiur_fn_555(
     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_556] = { let __args: [G; IN_556] = [__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[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_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[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 __v_9: G = __r_arr[0];
-    let __ret: [G; OUT_555] = [__v_9];
-    record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_558] = [__v_9];
+    record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_556: usize = 9;
-const IN_556: usize = 9;
-const OUT_556: usize = 1;
-fn aiur_fn_556(
-  inp: [G; IN_556],
+const INPUT_SIZE_559: usize = 9;
+const IN_559: usize = 9;
+const OUT_559: usize = 1;
+fn aiur_fn_559(
+  inp: [G; IN_559],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_556], ExecError> {
+) -> Result<[G; OUT_559], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48451,12 +47894,12 @@ fn aiur_fn_556(
         let __v_15: G = G::from_u64(1);
         let __v_16: G = G::from_u64(1);
         let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_556] = [__v_17];
-        record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_559] = [__v_17];
+        record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -48472,26 +47915,26 @@ fn aiur_fn_556(
         let __v_26: G = __loaded[10];
         match __v_16.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_10, __v_18, __v_19, __v_20, __v_13, __v_3, __v_5, __v_11, __v_12, __v_6, __v_7]; 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 __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_10, __v_18, __v_19, __v_20, __v_13, __v_3, __v_5, __v_11, __v_12, __v_6, __v_7]; 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_27: G = __r_arr[0];
             let __v_28: G = G::from_u64(0);
-            let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_27, __v_8, __v_28]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_27, __v_8, __v_28]; 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_29: G = __r_arr[0];
             let __v_30: G = G::from_u64(0);
             let __v_31: G = G::from_u64(1);
             let __v_32: G = (__v_8 + __v_31);
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_32]; 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 __v_33: G = __r_arr[0];
             let __v_34: G = { let __values: [G; 3] = [__v_30, __v_29, __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 __ret: [G; OUT_556] = [__v_34];
-            record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_559] = [__v_34];
+            record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_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[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_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[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 __v_27: G = __r_arr[0];
-            let __ret: [G; OUT_556] = [__v_27];
-            record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_559] = [__v_27];
+            record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -48503,15 +47946,15 @@ fn aiur_fn_556(
   })
 }
 
-const INPUT_SIZE_557: usize = 11;
-const IN_557: usize = 11;
-const OUT_557: usize = 1;
-fn aiur_fn_557(
-  inp: [G; IN_557],
+const INPUT_SIZE_560: usize = 11;
+const IN_560: usize = 11;
+const OUT_560: usize = 1;
+fn aiur_fn_560(
+  inp: [G; IN_560],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_557], ExecError> {
+) -> Result<[G; OUT_560], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48525,23 +47968,23 @@ fn aiur_fn_557(
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
     let __v_11: G = G::from_u64(0);
-    let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __v_12: G = __r_arr[0];
-    let __ret: [G; OUT_557] = [__v_12];
-    record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_560] = [__v_12];
+    record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_558: usize = 13;
-const IN_558: usize = 13;
-const OUT_558: usize = 1;
-fn aiur_fn_558(
-  inp: [G; IN_558],
+const INPUT_SIZE_561: usize = 13;
+const IN_561: usize = 13;
+const OUT_561: usize = 1;
+fn aiur_fn_561(
+  inp: [G; IN_561],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_558], ExecError> {
+) -> Result<[G; OUT_561], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48568,12 +48011,12 @@ fn aiur_fn_558(
         let __v_19: G = G::from_u64(1);
         let __v_20: G = G::from_u64(1);
         let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_558] = [__v_21];
-        record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_561] = [__v_21];
+        record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_9, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_9, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -48589,28 +48032,28 @@ fn aiur_fn_558(
         let __v_30: G = __loaded[10];
         match __v_20.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_25, __v_14, __v_15, __v_16, __v_17, __v_1, __v_2, __v_3, __v_4, __v_5, __v_8, __v_12, __v_9, __v_10, __v_11]; 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 __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_25, __v_14, __v_15, __v_16, __v_17, __v_1, __v_2, __v_3, __v_4, __v_5, __v_8, __v_12, __v_9, __v_10, __v_11]; 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_31]; 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_32: G = __r_arr[0];
             let __v_33: G = (__v_11 + __v_32);
             let __v_34: G = G::from_u64(1);
             let __v_35: G = (__v_12 + __v_34);
-            let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_33, __v_35]; 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 __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_33, __v_35]; 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 __v_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_31, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_31, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
             let __v_37: G = __r_arr[0];
-            let __ret: [G; OUT_558] = [__v_37];
-            record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_561] = [__v_37];
+            record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_31: G = G::from_u64(1);
             let __v_32: G = (__v_12 + __v_31);
-            let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_32]; 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 __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_32]; 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 __v_33: G = __r_arr[0];
-            let __ret: [G; OUT_558] = [__v_33];
-            record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_561] = [__v_33];
+            record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -48622,15 +48065,15 @@ fn aiur_fn_558(
   })
 }
 
-const INPUT_SIZE_559: usize = 11;
-const IN_559: usize = 11;
-const OUT_559: usize = 1;
-fn aiur_fn_559(
-  inp: [G; IN_559],
+const INPUT_SIZE_562: usize = 11;
+const IN_562: usize = 11;
+const OUT_562: usize = 1;
+fn aiur_fn_562(
+  inp: [G; IN_562],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_559], ExecError> {
+) -> Result<[G; OUT_562], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48647,9 +48090,9 @@ fn aiur_fn_559(
     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 __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_1, __v_11, __v_14, __v_9, __v_10]; 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 __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_1, __v_11, __v_14, __v_9, __v_10]; 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_15, __v_2, __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 __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_15, __v_2, __v_9, __v_10]; 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_16: G = __r_arr[0];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_16.as_canonical_u64() {
   1u64 => {
@@ -48671,40 +48114,40 @@ fn aiur_fn_559(
 }
  };
     let __v_17: G = __mc_out___mc_0[0];
-    let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_7, __v_9]; 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 __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_7, __v_9]; 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_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_18, __v_16, __v_9, __v_10]; 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 __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_18, __v_16, __v_9, __v_10]; 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_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_19]; 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 __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_19]; 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 __v_20: G = __r_arr[0];
-    let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } else { aiur_fn_783(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[786].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_786] = unsafe { *(result.output.as_ptr() as *const [G; OUT_786]) }; __ret } else { aiur_fn_786(__args, record, io_buffer, __cu)? } };
     let __v_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_19, __v_8]; 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 __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_19, __v_8]; 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_22: G = __r_arr[0];
     let __v_23: G = __r_arr[1];
     let __v_24: G = __r_arr[2];
     let __v_25: G = __r_arr[3];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_1, __v_25]; 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_1, __v_25]; 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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_26, __v_3]; 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 __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_26, __v_3]; 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 __v_28: G = __r_arr[1];
-    let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_19, __v_9]; 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 __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_19, __v_9]; 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_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_19, __v_3, __v_5, __v_17, __v_16, __v_3, __v_9, __v_10]; 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 __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_19, __v_3, __v_5, __v_17, __v_16, __v_3, __v_9, __v_10]; 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 __v_30: G = __r_arr[0];
     let __v_31: G = G::from_u64(0);
-    let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_19, __v_20, __v_29, __v_3, __v_21, __v_5, __v_16, __v_3, __v_9, __v_10, __v_31]; 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 __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_19, __v_20, __v_29, __v_3, __v_21, __v_5, __v_16, __v_3, __v_9, __v_10, __v_31]; 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_32: G = __r_arr[0];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
     let __v_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_28, __v_4, __v_9, __v_10]; 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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28, __v_4, __v_9, __v_10]; 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_34: G = __r_arr[0];
     let __v_35: G = (__v_21 + __v_33);
     let __v_36: G = G::from_u64(0);
-    let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_34, __v_35, __v_36]; 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 __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_34, __v_35, __v_36]; 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_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_19, __v_8]; 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 __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_19, __v_8]; 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_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -48719,10 +48162,10 @@ fn aiur_fn_559(
     let __v_49: G = (__v_47 - __v_48);
     let __v_50: G = (__v_33 + __v_4);
     let __v_51: G = (__v_21 + __v_50);
-    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_44, __v_3, __v_49, __v_51, __v_39, __v_40]; 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 __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_44, __v_3, __v_49, __v_51, __v_39, __v_40]; 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_52: G = __r_arr[0];
     let __v_53: G = G::from_u64(0);
-    let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_52, __v_4, __v_53]; 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 __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_52, __v_4, __v_53]; 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_54: G = __r_arr[0];
     let __v_55: G = G::from_u64(1);
     let __v_56: G = (__v_47 + __v_55);
@@ -48734,7 +48177,7 @@ fn aiur_fn_559(
     let __v_62: G = G::from_u64(0);
     let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __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 __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_63, __v_4, __v_64]; 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 __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_63, __v_4, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } };
     let __v_65: G = __r_arr[0];
     let __v_66: G = G::from_u64(3);
     let __v_67: G = G::from_u64(0);
@@ -48746,29 +48189,29 @@ fn aiur_fn_559(
     let __v_73: G = G::from_u64(5);
     let __v_74: G = G::from_u64(0);
     let __v_75: G = { let __values: [G; 4] = [__v_73, __v_54, __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 __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_75, __v_37]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_75, __v_37]; 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_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_76, __v_32]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_76, __v_32]; 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_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_77, __v_30]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_77, __v_30]; 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_78: G = __r_arr[0];
-    let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_78, __v_27]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_78, __v_27]; 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_79: G = __r_arr[0];
-    let __ret: [G; OUT_559] = [__v_79];
-    record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_562] = [__v_79];
+    record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_560: usize = 22;
-const IN_560: usize = 22;
-const OUT_560: usize = 1;
-fn aiur_fn_560(
-  inp: [G; IN_560],
+const INPUT_SIZE_563: usize = 22;
+const IN_563: usize = 22;
+const OUT_563: usize = 1;
+fn aiur_fn_563(
+  inp: [G; IN_563],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_560], ExecError> {
+) -> Result<[G; OUT_563], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48794,13 +48237,13 @@ fn aiur_fn_560(
     let __v_21: G = inp[21];
     let __v_22: G = (__v_8 + __v_9);
     let __v_23: G = G::from_u64(0);
-    let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_22, __v_23]; 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 __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_22, __v_23]; 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_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_3, __v_19]; 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_3, __v_19]; 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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_20]; 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 __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_20]; 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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_25, __v_26, __v_17, __v_18]; 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 __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_25, __v_26, __v_17, __v_18]; 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_27: G = __r_arr[0];
     let __v_28: G = G::from_u64(1);
     let __v_29: G = G::from_u64(1);
@@ -48816,14 +48259,14 @@ fn aiur_fn_560(
     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 = G::from_u64(0);
-    let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_27, __v_14, __v_30, __v_33, __v_36, __v_39, __v_20, __v_21, __v_40, __v_41]; 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 __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_27, __v_14, __v_30, __v_33, __v_36, __v_39, __v_20, __v_21, __v_40, __v_41]; 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_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 __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_42]; 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_46: G = __r_arr[0];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_43]; 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_47: G = __r_arr[0];
     let __v_48: G = (__v_7 + __v_46);
     let __v_49: G = (__v_6 + __v_48);
@@ -48837,41 +48280,41 @@ fn aiur_fn_560(
     let __v_57: G = G::from_u64(0);
     let __v_58: G = { let __values: [G; 4] = [__v_56, __v_55, __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 __v_59: G = G::from_u64(0);
-    let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_58, __v_46, __v_46, __v_59]; 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 __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_58, __v_46, __v_46, __v_59]; 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_60: G = __r_arr[0];
     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 __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_60, __v_43, __v_44, __v_42, __v_13, __v_16, __v_5, __v_6, __v_7, __v_46, __v_24, __v_63, __v_20, __v_21, __v_64]; 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 __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_60, __v_43, __v_44, __v_42, __v_13, __v_16, __v_5, __v_6, __v_7, __v_46, __v_24, __v_63, __v_20, __v_21, __v_64]; 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_65: G = __r_arr[0];
     let __v_66: G = (__v_6 + __v_7);
     let __v_67: G = G::from_u64(0);
-    let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_42, __v_66, __v_67]; 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 __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_42, __v_66, __v_67]; 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_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_65, __v_68]; 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 __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_65, __v_68]; 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_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_69, __v_11]; 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 __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_69, __v_11]; 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_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_70, __v_10]; 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 __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_70, __v_10]; 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_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_71, __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 __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_71, __v_12]; 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_72: G = __r_arr[0];
-    let __ret: [G; OUT_560] = [__v_72];
-    record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_563] = [__v_72];
+    record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_561: usize = 2;
-const IN_561: usize = 2;
-const OUT_561: usize = 1;
-fn aiur_fn_561(
-  inp: [G; IN_561],
+const INPUT_SIZE_564: usize = 2;
+const IN_564: usize = 2;
+const OUT_564: usize = 1;
+fn aiur_fn_564(
+  inp: [G; IN_564],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_561], ExecError> {
+) -> Result<[G; OUT_564], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48881,8 +48324,8 @@ fn aiur_fn_561(
         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_561] = [__v_5];
-        record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_564] = [__v_5];
+        record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48892,26 +48335,26 @@ fn aiur_fn_561(
         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_561] = { let __args: [G; IN_561] = [__v_0, __v_8]; 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 __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_0, __v_8]; 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_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_561] = [__v_10];
-        record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_564] = [__v_10];
+        record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_562: usize = 2;
-const IN_562: usize = 2;
-const OUT_562: usize = 1;
-fn aiur_fn_562(
-  inp: [G; IN_562],
+const INPUT_SIZE_565: usize = 2;
+const IN_565: usize = 2;
+const OUT_565: usize = 1;
+fn aiur_fn_565(
+  inp: [G; IN_565],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_562], ExecError> {
+) -> Result<[G; OUT_565], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48921,18 +48364,18 @@ fn aiur_fn_562(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_562] = [__v_0];
-        record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_565] = [__v_0];
+        record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(4);
-        let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_4]; 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_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_562] = [__v_8];
-        record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_565] = [__v_8];
+        record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48942,15 +48385,15 @@ fn aiur_fn_562(
   })
 }
 
-const INPUT_SIZE_563: usize = 15;
-const IN_563: usize = 15;
-const OUT_563: usize = 1;
-fn aiur_fn_563(
-  inp: [G; IN_563],
+const INPUT_SIZE_566: usize = 15;
+const IN_566: usize = 15;
+const OUT_566: usize = 1;
+fn aiur_fn_566(
+  inp: [G; IN_566],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_563], ExecError> {
+) -> Result<[G; OUT_566], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48973,41 +48416,41 @@ fn aiur_fn_563(
     let __v_17: G = __loaded[2];
     match __v_15.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_563] = [__v_0];
-        record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_566] = [__v_0];
+        record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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_767] = { let __args: [G; IN_767] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
         let __v_25: G = (__v_9 - __v_16);
         let __v_26: G = G::from_u64(0);
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_24, __v_25, __v_26]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_24, __v_25, __v_26]; 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_27: G = __r_arr[0];
         let __v_28: G = (__v_7 + __v_8);
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_27, __v_28, __v_9]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_27, __v_28, __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_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_29, __v_11, __v_12, __v_13]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_29, __v_11, __v_12, __v_13]; 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_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_30]; 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 __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
-        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
         let __v_33: G = __r_arr[0];
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_33, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_33, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
         let __v_34: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_32, __v_34, __v_12, __v_13]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_32, __v_34, __v_12, __v_13]; 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_35: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_31]; 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_36: G = __r_arr[0];
         let __v_37: G = (__v_23 + __v_36);
         let __v_38: G = G::from_u64(2);
@@ -49016,27 +48459,27 @@ fn aiur_fn_563(
         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_549] = { let __args: [G; IN_549] = [__v_40, __v_6, __v_42, __v_43]; 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 __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_40, __v_6, __v_42, __v_43]; 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_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_549] = { let __args: [G; IN_549] = [__v_44, __v_7, __v_47, __v_48]; 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 __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_44, __v_7, __v_47, __v_48]; 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_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_549] = { let __args: [G; IN_549] = [__v_49, __v_8, __v_53, __v_54]; 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 __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_49, __v_8, __v_53, __v_54]; 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
         let __v_57: G = __r_arr[1];
-        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_57, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_57, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__args, record, io_buffer, __cu)? } };
         let __v_58: G = __r_arr[0];
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_55, __v_58]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_55, __v_58]; 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_59: G = __r_arr[0];
         let __v_60: G = G::from_u64(1);
         let __v_61: G = (__v_9 - __v_60);
@@ -49046,22 +48489,22 @@ fn aiur_fn_563(
         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_530] = { let __args: [G; IN_530] = [__v_66, __v_36, __v_67]; 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 __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_66, __v_36, __v_67]; 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_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_562] = { let __args: [G; IN_562] = [__v_71, __v_31]; 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 __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_71, __v_31]; 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_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_563] = { let __args: [G; IN_563] = [__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[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 __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__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[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_78: G = __r_arr[0];
-        let __ret: [G; OUT_563] = [__v_78];
-        record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_566] = [__v_78];
+        record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -49071,15 +48514,15 @@ fn aiur_fn_563(
   })
 }
 
-const INPUT_SIZE_564: usize = 7;
-const IN_564: usize = 7;
-const OUT_564: usize = 1;
-fn aiur_fn_564(
-  inp: [G; IN_564],
+const INPUT_SIZE_567: usize = 7;
+const IN_567: usize = 7;
+const OUT_567: usize = 1;
+fn aiur_fn_567(
+  inp: [G; IN_567],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_564], ExecError> {
+) -> Result<[G; OUT_567], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49091,7 +48534,7 @@ fn aiur_fn_564(
     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_491] = { let __args: [G; IN_491] = [__v_1, __v_9]; 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 __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_1, __v_9]; 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_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];
@@ -49100,7 +48543,7 @@ fn aiur_fn_564(
     let __v_14: G = __loaded[3];
     match __v_11.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_12]; 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_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 };
@@ -49110,8 +48553,8 @@ fn aiur_fn_564(
         let __v_20: G = __loaded[3];
         match __v_17.as_canonical_u64() {
           2u64 => {
-            let __ret: [G; OUT_564] = [__v_18];
-            record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_567] = [__v_18];
+            record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -49126,15 +48569,15 @@ fn aiur_fn_564(
   })
 }
 
-const INPUT_SIZE_565: usize = 6;
-const IN_565: usize = 6;
-const OUT_565: usize = 1;
-fn aiur_fn_565(
-  inp: [G; IN_565],
+const INPUT_SIZE_568: usize = 6;
+const IN_568: usize = 6;
+const OUT_568: usize = 1;
+fn aiur_fn_568(
+  inp: [G; IN_568],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_565], ExecError> {
+) -> Result<[G; OUT_568], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49145,7 +48588,7 @@ fn aiur_fn_565(
     let __v_6: G = (__v_1 + __v_2);
     let __v_7: G = (__v_6 + __v_3);
     let __v_8: G = (__v_7 + __v_4);
-    let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_0, __v_8]; 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 __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !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_9: G = __r_arr[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_10: G = __loaded[0];
@@ -49154,40 +48597,40 @@ fn aiur_fn_565(
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       5u64 => {
-        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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_11]; 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[784].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_784] = unsafe { *(result.output.as_ptr() as *const [G; OUT_784]) }; __ret } else { aiur_fn_784(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = (__v_2 + __v_3);
         let __v_18: G = (__v_17 + __v_4);
-        let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_16, __v_18]; 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_19: G = __r_arr[0];
-        let __ret: [G; OUT_565] = [__v_19];
-        record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_568] = [__v_19];
+        record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(1);
         let __v_15: G = G::from_u64(1);
         let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_565] = [__v_16];
-        record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_568] = [__v_16];
+        record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_566: usize = 6;
-const IN_566: usize = 6;
-const OUT_566: usize = 1;
-fn aiur_fn_566(
-  inp: [G; IN_566],
+const INPUT_SIZE_569: usize = 6;
+const IN_569: usize = 6;
+const OUT_569: usize = 1;
+fn aiur_fn_569(
+  inp: [G; IN_569],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_566], ExecError> {
+) -> Result<[G; OUT_569], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49197,36 +48640,36 @@ fn aiur_fn_566(
     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_567] = { let __args: [G; IN_567] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_6, __v_5, __v_5, __v_7]; 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 __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_6, __v_5, __v_5, __v_7]; 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_8: G = __r_arr[0];
     match __v_8.as_canonical_u64() {
       0u64 => {
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_9, __v_5, __v_5, __v_10]; 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 __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_9, __v_5, __v_5, __v_10]; 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_566] = [__v_11];
-        record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_569] = [__v_11];
+        record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_566] = [__v_8];
-        record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_569] = [__v_8];
+        record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_567: usize = 9;
-const IN_567: usize = 9;
-const OUT_567: usize = 1;
-fn aiur_fn_567(
-  inp: [G; IN_567],
+const INPUT_SIZE_570: usize = 9;
+const IN_570: usize = 9;
+const OUT_570: usize = 1;
+fn aiur_fn_570(
+  inp: [G; IN_570],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_567], ExecError> {
+) -> Result<[G; OUT_570], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49244,8 +48687,8 @@ fn aiur_fn_567(
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_567] = [__v_12];
-        record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_570] = [__v_12];
+        record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -49263,7 +48706,7 @@ fn aiur_fn_567(
         let __v_22: G = __loaded[10];
         match __v_12.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_19, __v_14, __v_15, __v_17, __v_18, __v_16, __v_7]; 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 __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_19, __v_14, __v_15, __v_17, __v_18, __v_16, __v_7]; 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_23: G = __r_arr[0];
             let __v_24: G = (__v_23 - __v_0);
             let __v_25: G = G::from_bool((__v_24 == G::ZERO));
@@ -49273,7 +48716,7 @@ fn aiur_fn_567(
     break '__mc_0 [__v_26];
   },
   _ => {
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_22, __v_4]; 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_26: G = __r_arr[0];
     break '__mc_0 [__v_26];
   },
@@ -49289,9 +48732,9 @@ fn aiur_fn_567(
     break '__mc_1 [__v_28];
   },
   _ => {
-    let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_14, __v_15, __v_17, __v_18, __v_16, __v_3]; 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 __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_14, __v_15, __v_17, __v_18, __v_16, __v_3]; 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_28: G = __r_arr[0];
-    let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_28, __v_2]; 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 __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_28, __v_2]; 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_29: G = __r_arr[0];
     break '__mc_1 [__v_29];
   },
@@ -49300,17 +48743,17 @@ fn aiur_fn_567(
                 let __v_28: G = __mc_out___mc_1[0];
                 match __v_28.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_567] = [__v_8];
-                    record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_570] = [__v_8];
+                    record.function_queries[570].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_567] = { let __args: [G; IN_567] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_30]; 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 __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_30]; 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_31: G = __r_arr[0];
-                    let __ret: [G; OUT_567] = [__v_31];
-                    record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_570] = [__v_31];
+                    record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -49321,10 +48764,10 @@ fn aiur_fn_567(
               0u64 => {
                 let __v_28: G = G::from_u64(1);
                 let __v_29: G = (__v_8 + __v_28);
-                let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_29]; 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 __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_29]; 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_30: G = __r_arr[0];
-                let __ret: [G; OUT_567] = [__v_30];
-                record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_570] = [__v_30];
+                record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -49335,10 +48778,10 @@ fn aiur_fn_567(
           _ => {
             let __v_23: G = G::from_u64(1);
             let __v_24: G = (__v_8 + __v_23);
-            let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_24]; 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 __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_24]; 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_25: G = __r_arr[0];
-            let __ret: [G; OUT_567] = [__v_25];
-            record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_570] = [__v_25];
+            record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -49350,15 +48793,15 @@ fn aiur_fn_567(
   })
 }
 
-const INPUT_SIZE_568: usize = 3;
-const IN_568: usize = 3;
-const OUT_568: usize = 1;
-fn aiur_fn_568(
-  inp: [G; IN_568],
+const INPUT_SIZE_571: usize = 3;
+const IN_571: usize = 3;
+const OUT_571: usize = 1;
+fn aiur_fn_571(
+  inp: [G; IN_571],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_568], ExecError> {
+) -> Result<[G; OUT_571], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49375,12 +48818,12 @@ fn aiur_fn_568(
         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_568] = [__v_11];
-        record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_571] = [__v_11];
+        record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -49406,13 +48849,13 @@ fn aiur_fn_568(
  };
         let __v_21: G = __mc_out___mc_0[0];
         let __v_22: G = G::from_u64(0);
-        let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_5, __v_6, __v_21, __v_1, __v_2]; 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 __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_4, __v_5, __v_6, __v_21, __v_1, __v_2]; 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_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_8, __v_1, __v_2]; 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 __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_8, __v_1, __v_2]; 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_24: G = __r_arr[0];
         let __v_25: G = { let __values: [G; 3] = [__v_22, __v_23, __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 __ret: [G; OUT_568] = [__v_25];
-        record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_571] = [__v_25];
+        record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -49422,15 +48865,15 @@ fn aiur_fn_568(
   })
 }
 
-const INPUT_SIZE_569: usize = 2;
-const IN_569: usize = 2;
-const OUT_569: usize = 1;
-fn aiur_fn_569(
-  inp: [G; IN_569],
+const INPUT_SIZE_572: usize = 2;
+const IN_572: usize = 2;
+const OUT_572: usize = 1;
+fn aiur_fn_572(
+  inp: [G; IN_572],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_569], ExecError> {
+) -> Result<[G; OUT_572], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49444,7 +48887,7 @@ fn aiur_fn_569(
       0u64 => {
         match __v_3.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __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];
@@ -49460,8 +48903,8 @@ fn aiur_fn_569(
             let __v_18: G = __loaded[10];
             match __v_8.as_canonical_u64() {
               6u64 => {
-                let __ret: [G; OUT_569] = [__v_11];
-                record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_572] = [__v_11];
+                record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -49478,15 +48921,15 @@ fn aiur_fn_569(
   })
 }
 
-const INPUT_SIZE_570: usize = 3;
-const IN_570: usize = 3;
-const OUT_570: usize = 1;
-fn aiur_fn_570(
-  inp: [G; IN_570],
+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_570], ExecError> {
+) -> Result<[G; OUT_573], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49500,21 +48943,21 @@ fn aiur_fn_570(
         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_570] = [__v_8];
-        record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_573] = [__v_8];
+        record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __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 __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_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_570] = { let __args: [G; IN_570] = [__v_5, __v_1, __v_9]; 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 __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_5, __v_1, __v_9]; 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_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_570] = [__v_11];
-        record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_573] = [__v_11];
+        record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -49524,15 +48967,15 @@ fn aiur_fn_570(
   })
 }
 
-const INPUT_SIZE_571: usize = 4;
-const IN_571: usize = 4;
-const OUT_571: usize = 0;
-fn aiur_fn_571(
-  inp: [G; IN_571],
+const INPUT_SIZE_574: usize = 4;
+const IN_574: usize = 4;
+const OUT_574: usize = 0;
+fn aiur_fn_574(
+  inp: [G; IN_574],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_571], ExecError> {
+) -> Result<[G; OUT_574], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49554,8 +48997,8 @@ fn aiur_fn_571(
         let __v_13: G = __loaded[4];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_571] = [];
-            record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_574] = [];
+            record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -49576,24 +49019,24 @@ fn aiur_fn_571(
               _ => {
                 match __v_10.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_460] = { let __args: [G; IN_460] = [__v_7, __v_12, __v_16, __v_2, __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_17: G = __r_arr[0];
                     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_457] = { let __args: [G; IN_457] = [__v_7, __v_12, __v_16, __v_2, __v_3]; 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_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_571] = { let __args: [G; IN_571] = [__v_8, __v_13, __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 __ret: [G; OUT_571] = [];
-                    record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_8, __v_13, __v_2, __v_3]; 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 __ret: [G; OUT_574] = [];
+                    record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -49612,15 +49055,15 @@ fn aiur_fn_571(
   })
 }
 
-const INPUT_SIZE_572: usize = 13;
-const IN_572: usize = 13;
-const OUT_572: usize = 0;
-fn aiur_fn_572(
-  inp: [G; IN_572],
+const INPUT_SIZE_575: usize = 13;
+const IN_575: usize = 13;
+const OUT_575: usize = 0;
+fn aiur_fn_575(
+  inp: [G; IN_575],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_572], ExecError> {
+) -> Result<[G; OUT_575], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49637,7 +49080,7 @@ fn aiur_fn_572(
     let __v_12: G = inp[12];
     match __v_1.as_canonical_u64() {
       6u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -49653,13 +49096,13 @@ fn aiur_fn_572(
         let __v_24: G = __loaded[10];
         match __v_14.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_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_572] = [];
-            record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_575] = [];
+            record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -49674,20 +49117,20 @@ fn aiur_fn_572(
   })
 }
 
-const INPUT_SIZE_573: usize = 3;
-const IN_573: usize = 3;
-const OUT_573: usize = 1;
-fn aiur_fn_573(
-  inp: [G; IN_573],
+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_573], ExecError> {
+) -> Result<[G; OUT_576], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __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];
@@ -49703,9 +49146,9 @@ fn aiur_fn_573(
     let __v_14: G = __loaded[10];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_1]; 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_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_15]; 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_16: G = __r_arr[0];
         let __v_17: G = G::from_u64(1);
         let __v_18: G = (__v_16 - __v_17);
@@ -49715,31 +49158,31 @@ fn aiur_fn_573(
             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_494] = { let __args: [G; IN_494] = [__v_6, __v_19, __v_22, __v_1, __v_2]; 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 __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_6, __v_19, __v_22, __v_1, __v_2]; 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_23: G = __r_arr[0];
             let __v_24: G = G::from_u64(0);
             let __v_25: G = G::from_u64(0);
             let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_23, __v_26]; 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_23, __v_26]; 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_27: G = __r_arr[0];
             match __v_27.as_canonical_u64() {
               0u64 => {
                 let __v_28: G = G::from_u64(0);
-                let __ret: [G; OUT_573] = [__v_28];
-                record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_576] = [__v_28];
+                record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_9]; 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_28: G = __r_arr[0];
                 let __v_29: G = G::from_u64(1);
                 let __v_30: G = (__v_28 - __v_29);
                 match __v_30.as_canonical_u64() {
                   0u64 => {
                     let __v_31: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                     let __v_32: G = __r_arr[0];
-                    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                     let __v_33: G = __r_arr[0];
                     let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
                     let __v_34: G = __loaded[0];
@@ -49756,22 +49199,22 @@ fn aiur_fn_573(
                     match __v_34.as_canonical_u64() {
                       6u64 => {
                         let __v_45: G = G::from_bool((__v_40 == G::ZERO));
-                        let __ret: [G; OUT_573] = [__v_45];
-                        record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_576] = [__v_45];
+                        record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_45: G = G::from_u64(0);
-                        let __ret: [G; OUT_573] = [__v_45];
-                        record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_576] = [__v_45];
+                        record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_31: G = G::from_u64(0);
-                    let __ret: [G; OUT_573] = [__v_31];
-                    record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_576] = [__v_31];
+                    record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -49783,31 +49226,31 @@ fn aiur_fn_573(
           },
           _ => {
             let __v_19: G = G::from_u64(0);
-            let __ret: [G; OUT_573] = [__v_19];
-            record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_576] = [__v_19];
+            record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_15: G = G::from_u64(0);
-        let __ret: [G; OUT_573] = [__v_15];
-        record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_576] = [__v_15];
+        record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_574: usize = 2;
-const IN_574: usize = 2;
-const OUT_574: usize = 1;
-fn aiur_fn_574(
-  inp: [G; IN_574],
+const INPUT_SIZE_577: usize = 2;
+const IN_577: usize = 2;
+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_574], ExecError> {
+) -> Result<[G; OUT_577], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49831,22 +49274,22 @@ fn aiur_fn_574(
             match __v_12.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __ret: [G; OUT_574] = [__v_13];
-                record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_577] = [__v_13];
+                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(0);
-                let __ret: [G; OUT_574] = [__v_13];
-                record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_577] = [__v_13];
+                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_574] = [__v_10];
-            record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_577] = [__v_10];
+            record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -49860,14 +49303,14 @@ fn aiur_fn_574(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_574] = [__v_10];
-            record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_577] = [__v_10];
+            record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_574] = [__v_10];
-            record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_577] = [__v_10];
+            record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -49886,22 +49329,22 @@ fn aiur_fn_574(
             match __v_12.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __ret: [G; OUT_574] = [__v_13];
-                record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_577] = [__v_13];
+                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(0);
-                let __ret: [G; OUT_574] = [__v_13];
-                record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_577] = [__v_13];
+                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_574] = [__v_10];
-            record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_577] = [__v_10];
+            record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -49914,28 +49357,28 @@ fn aiur_fn_574(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_7]; 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 __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_7]; 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_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_8]; 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 __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_8]; 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_574] = [__v_11];
-                record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_577] = [__v_11];
+                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_574] = [__v_11];
-                record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_577] = [__v_11];
+                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_574] = [__v_10];
-            record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_577] = [__v_10];
+            record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -49948,28 +49391,28 @@ fn aiur_fn_574(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_7]; 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 __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_7]; 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_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_8]; 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 __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_8]; 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_574] = [__v_11];
-                record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_577] = [__v_11];
+                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_574] = [__v_11];
-                record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_577] = [__v_11];
+                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_574] = [__v_10];
-            record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_577] = [__v_10];
+            record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -49982,51 +49425,51 @@ fn aiur_fn_574(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_7]; 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 __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_7]; 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_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_8]; 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 __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_8]; 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_574] = [__v_11];
-                record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_577] = [__v_11];
+                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_574] = [__v_11];
-                record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_577] = [__v_11];
+                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_574] = [__v_10];
-            record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_577] = [__v_10];
+            record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_574] = [__v_6];
-        record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_577] = [__v_6];
+        record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_575: usize = 8;
-const IN_575: usize = 8;
-const OUT_575: usize = 1;
-fn aiur_fn_575(
-  inp: [G; IN_575],
+const INPUT_SIZE_578: usize = 8;
+const IN_578: usize = 8;
+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_575], ExecError> {
+) -> Result<[G; OUT_578], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50036,7 +49479,7 @@ fn aiur_fn_575(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __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];
@@ -50052,35 +49495,35 @@ fn aiur_fn_575(
     let __v_19: G = __loaded[10];
     match __v_9.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_12]; 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 __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_0, __v_1, __v_2, __v_3, __v_4, __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_20: G = __r_arr[0];
         let __v_21: G = G::from_u64(0);
         let __v_22: G = G::from_u64(0);
-        let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_6, __v_5, __v_20, __v_21, __v_22]; 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 __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_6, __v_5, __v_20, __v_21, __v_22]; 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_23: G = __r_arr[0];
-        let __ret: [G; OUT_575] = [__v_23];
-        record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_578] = [__v_23];
+        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_20: G = G::from_u64(0);
-        let __ret: [G; OUT_575] = [__v_20];
-        record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_578] = [__v_20];
+        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_576: usize = 5;
-const IN_576: usize = 5;
-const OUT_576: usize = 1;
-fn aiur_fn_576(
-  inp: [G; IN_576],
+const INPUT_SIZE_579: usize = 5;
+const IN_579: usize = 5;
+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_576], ExecError> {
+) -> Result<[G; OUT_579], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50099,15 +49542,15 @@ fn aiur_fn_576(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_576] = [__v_11];
-            record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_579] = [__v_11];
+            record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(1);
             let __v_12: G = (__v_4 - __v_11);
-            let __ret: [G; OUT_576] = [__v_12];
-            record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_579] = [__v_12];
+            record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50132,26 +49575,26 @@ fn aiur_fn_576(
             let __v_14: G = __mc_out___mc_0[0];
             match __v_7.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_576] = [__v_3];
-                record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_579] = [__v_3];
+                record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_8, __v_2]; 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 __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_8, __v_2]; 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_15: G = __r_arr[0];
                 match __v_15.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_576] = [__v_3];
-                    record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_579] = [__v_3];
+                    record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_16: G = G::from_u64(1);
                     let __v_17: G = (__v_3 + __v_16);
-                    let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_10, __v_1, __v_2, __v_17, __v_14]; 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 __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_10, __v_1, __v_2, __v_17, __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_18: G = __r_arr[0];
-                    let __ret: [G; OUT_576] = [__v_18];
-                    record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_579] = [__v_18];
+                    record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -50164,10 +49607,10 @@ fn aiur_fn_576(
           _ => {
             let __v_14: G = G::from_u64(1);
             let __v_15: G = (__v_3 + __v_14);
-            let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_10, __v_1, __v_2, __v_15, __v_4]; 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 __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_10, __v_1, __v_2, __v_15, __v_4]; 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_16: G = __r_arr[0];
-            let __ret: [G; OUT_576] = [__v_16];
-            record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_579] = [__v_16];
+            record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50179,15 +49622,15 @@ fn aiur_fn_576(
   })
 }
 
-const INPUT_SIZE_577: usize = 14;
-const IN_577: usize = 14;
-const OUT_577: usize = 0;
-fn aiur_fn_577(
-  inp: [G; IN_577],
+const INPUT_SIZE_580: usize = 14;
+const IN_580: usize = 14;
+const OUT_580: usize = 0;
+fn aiur_fn_580(
+  inp: [G; IN_580],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_577], ExecError> {
+) -> Result<[G; OUT_580], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50205,17 +49648,14 @@ fn aiur_fn_577(
     let __v_13: G = inp[13];
     match __v_1.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; 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 __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; 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_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_14, __v_12, __v_13]; 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 __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_14, __v_11, __v_12]; 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 __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_14, __v_12, __v_13]; 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 __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_14, __v_11, __v_12]; 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_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_14, __v_12, __v_13]; 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 __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_14, __v_12, __v_13]; 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_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_767] = { let __args: [G; IN_767] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -50229,7 +49669,7 @@ fn aiur_fn_577(
         let __v_26: G = __loaded[8];
         let __v_27: G = __loaded[9];
         let __v_28: G = __loaded[10];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -50243,6 +49683,9 @@ fn aiur_fn_577(
         let __v_38: G = __loaded[8];
         let __v_39: G = __loaded[9];
         let __v_40: G = __loaded[10];
+        if (__v_9 != __v_16) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
+        }
         match __v_18.as_canonical_u64() {
           5u64 => {
             match __v_30.as_canonical_u64() {
@@ -50251,9 +49694,9 @@ fn aiur_fn_577(
                 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_494] = { let __args: [G; IN_494] = [__v_32, __v_41, __v_44, __v_12, __v_13]; 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 __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_32, __v_41, __v_44, __v_12, __v_13]; 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_45: G = __r_arr[0];
-                let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_45, __v_35, __v_12, __v_13]; 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 __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_45, __v_35, __v_12, __v_13]; 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_46: G = __r_arr[0];
                 let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_46.as_canonical_u64() {
   1u64 => {
@@ -50275,59 +49718,59 @@ fn aiur_fn_577(
 }
  };
                 let __v_47: G = __mc_out___mc_0[0];
-                let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_15, __v_12]; 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 __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_15, __v_12]; 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_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_48, __v_46, __v_12, __v_13]; 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 __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_48, __v_46, __v_12, __v_13]; 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_4, __v_6, __v_7, __v_5, __v_14, __v_49, __v_12]; 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 __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_4, __v_6, __v_7, __v_5, __v_14, __v_49, __v_12]; 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_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_14, __v_32, __v_35, __v_21, __v_34, __v_19, __v_33, __v_15, __v_50, __v_12, __v_13]; 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_562] = { let __args: [G; IN_562] = [__v_14, __v_32, __v_35, __v_21, __v_34, __v_19, __v_33, __v_15, __v_50, __v_12, __v_13]; 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_51: G = __r_arr[0];
                 let __v_52: G = G::from_u64(1);
                 let __v_53: G = G::from_u64(1);
                 let __v_54: G = { let __values: [G; 3] = [__v_52, __v_53, __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 __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_3, __v_51, __v_54, __v_12, __v_13]; 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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_3, __v_51, __v_54, __v_12, __v_13]; 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_55: G = __r_arr[0];
-                let __v_56: G = G::from_u64(1);
-                if (__v_55 != __v_56) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_56.as_canonical_u64() });
-                }
-                let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_49]; 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 __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_49]; 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 __v_56: G = __r_arr[0];
+                let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[786].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_786] = unsafe { *(result.output.as_ptr() as *const [G; OUT_786]) }; __ret } else { aiur_fn_786(__args, record, io_buffer, __cu)? } };
                 let __v_57: G = __r_arr[0];
-                let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } else { aiur_fn_783(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_49, __v_12]; 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_58: G = __r_arr[0];
-                let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_49, __v_12]; 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 __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_49, __v_21, __v_19, __v_47, __v_46, __v_21, __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 __v_59: G = __r_arr[0];
-                let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_49, __v_21, __v_19, __v_47, __v_46, __v_21, __v_12, __v_13]; 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_60: G = __r_arr[0];
-                let __v_61: G = G::from_u64(0);
-                let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_49, __v_57, __v_59, __v_21, __v_58, __v_19, __v_46, __v_21, __v_12, __v_13, __v_61]; 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_60: G = G::from_u64(0);
+                let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_49, __v_56, __v_58, __v_21, __v_57, __v_19, __v_46, __v_21, __v_12, __v_13, __v_60]; 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_61: G = __r_arr[0];
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_61]; 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_62: G = __r_arr[0];
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_62]; 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_63: G = __r_arr[0];
-                let __v_64: G = G::from_u64(0);
-                let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_57, __v_50, __v_12, __v_64]; 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_65: G = __r_arr[0];
-                let __v_66: G = G::from_u64(0);
-                let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_46, __v_19, __v_66]; 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_63: G = G::from_u64(0);
+                let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_56, __v_50, __v_12, __v_63]; 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_64: G = __r_arr[0];
+                let __v_65: G = G::from_u64(0);
+                let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_46, __v_19, __v_65]; 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_66: G = __r_arr[0];
+                let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_20, __v_66]; 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_67: G = __r_arr[0];
-                let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_20, __v_67]; 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 __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_67, __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_68: G = __r_arr[0];
-                let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_68, __v_21]; 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_69: G = __r_arr[0];
-                let __v_70: G = __r_arr[1];
-                let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_49, __v_11, __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_69: G = __r_arr[1];
+                let __v_70: G = G::from_u64(1);
+                if (__v_55 != __v_70) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_70.as_canonical_u64() });
+                }
+                let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_49, __v_11, __v_12]; 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_71: G = __r_arr[0];
-                let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_49, __v_50]; 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 __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_49, __v_50]; 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_72: G = __r_arr[0];
                 let __v_73: G = __r_arr[1];
                 let __v_74: G = __r_arr[2];
                 let __v_75: G = __r_arr[3];
-                let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_14, __v_35, __v_21, __v_58, __v_63, __v_19, __v_46, __v_60, __v_62, __v_69, __v_71, __v_49, __v_57, __v_59, __v_73, __v_74, __v_75, __v_12, __v_13, __v_65]; 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 __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_0, __v_14, __v_35, __v_21, __v_57, __v_62, __v_19, __v_46, __v_59, __v_61, __v_68, __v_71, __v_49, __v_56, __v_58, __v_73, __v_74, __v_75, __v_12, __v_13, __v_64]; 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_76: G = __r_arr[0];
-                let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_8, __v_76, __v_12, __v_13]; 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 __ret: [G; OUT_577] = [];
-                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_8, __v_76, __v_12, __v_13]; 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 __ret: [G; OUT_580] = [];
+                record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -50347,43 +49790,43 @@ fn aiur_fn_577(
   })
 }
 
-const INPUT_SIZE_578: usize = 4;
-const IN_578: usize = 4;
-const OUT_578: usize = 1;
-fn aiur_fn_578(
-  inp: [G; IN_578],
+const INPUT_SIZE_581: usize = 4;
+const IN_581: usize = 4;
+const OUT_581: usize = 1;
+fn aiur_fn_581(
+  inp: [G; IN_581],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_578], ExecError> {
+) -> Result<[G; OUT_581], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = 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_585] = { let __args: [G; IN_585] = [__v_0, __v_1, __v_2]; 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 __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_1, __v_2]; 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 __v_4: G = __r_arr[0];
     let __v_5: G = G::from_u64(0);
-    let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_5, __v_0, __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 __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_4, __v_5, __v_0, __v_2, __v_3]; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } else { aiur_fn_783(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[786].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_786] = unsafe { *(result.output.as_ptr() as *const [G; OUT_786]) }; __ret } else { aiur_fn_786(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __v_9: G = (__v_8 - __v_7);
     let __v_10: G = G::from_u64(1);
     let __v_11: G = { let __a_val = __v_10.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_11.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_578] = [__v_6];
-        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_581] = [__v_6];
+        record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_6, __v_7, __v_2, __v_3]; 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_591] = { let __args: [G; IN_591] = [__v_6, __v_7, __v_2, __v_3]; 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 __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_578] = [__v_12];
-        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_581] = [__v_12];
+        record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -50393,61 +49836,61 @@ fn aiur_fn_578(
   })
 }
 
-const INPUT_SIZE_579: usize = 5;
-const IN_579: usize = 5;
-const OUT_579: usize = 1;
-fn aiur_fn_579(
-  inp: [G; IN_579],
+const INPUT_SIZE_582: usize = 5;
+const IN_582: usize = 5;
+const OUT_582: usize = 1;
+fn aiur_fn_582(
+  inp: [G; IN_582],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_579], ExecError> {
+) -> Result<[G; OUT_582], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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_783] = { let __args: [G; IN_783] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } else { aiur_fn_783(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[786].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_786] = unsafe { *(result.output.as_ptr() as *const [G; OUT_786]) }; __ret } else { aiur_fn_786(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = { let __a_val = __v_1.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() {
       0u64 => {
-        let __ret: [G; OUT_579] = [__v_0];
-        record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_582] = [__v_0];
+        record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_1]; 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_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 __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_7, __v_8, __v_9, __v_10, __v_2, __v_3, __v_4]; 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_583] = { let __args: [G; IN_583] = [__v_7, __v_8, __v_9, __v_10, __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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_11]; 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 __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_0, __v_11]; 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_12: G = __r_arr[0];
         let __v_13: G = G::from_u64(1);
         let __v_14: G = (__v_1 + __v_13);
-        let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_12, __v_14, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_12, __v_14, __v_2, __v_3, __v_4]; 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_15: G = __r_arr[0];
-        let __ret: [G; OUT_579] = [__v_15];
-        record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_582] = [__v_15];
+        record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_580: usize = 7;
-const IN_580: usize = 7;
-const OUT_580: usize = 1;
-fn aiur_fn_580(
-  inp: [G; IN_580],
+const INPUT_SIZE_583: usize = 7;
+const IN_583: usize = 7;
+const OUT_583: usize = 1;
+fn aiur_fn_583(
+  inp: [G; IN_583],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_580], ExecError> {
+) -> Result<[G; OUT_583], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50456,7 +49899,7 @@ fn aiur_fn_580(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __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];
@@ -50472,33 +49915,33 @@ fn aiur_fn_580(
     let __v_18: G = __loaded[10];
     match __v_8.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_13, __v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_13, __v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_19: G = __r_arr[0];
-        let __ret: [G; OUT_580] = [__v_19];
-        record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_583] = [__v_19];
+        record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_19: G = G::from_u64(1);
         let __v_20: G = G::from_u64(1);
         let __v_21: G = { let __values: [G; 5] = [__v_19, __v_20, __v_20, __v_20, __v_20]; 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_580] = [__v_21];
-        record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_583] = [__v_21];
+        record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_581: usize = 8;
-const IN_581: usize = 8;
-const OUT_581: usize = 1;
-fn aiur_fn_581(
-  inp: [G; IN_581],
+const INPUT_SIZE_584: usize = 8;
+const IN_584: usize = 8;
+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_581], ExecError> {
+) -> Result<[G; OUT_584], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50517,12 +49960,12 @@ fn aiur_fn_581(
         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_581] = [__v_13];
-        record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_584] = [__v_13];
+        record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __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];
@@ -50540,12 +49983,12 @@ fn aiur_fn_581(
           6u64 => {
             let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
   0u64 => {
-    let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_14, __v_1]; 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 __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_14, __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_23: G = __r_arr[0];
     break '__mc_0 [__v_23];
   },
   _ => {
-    let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_14, __v_1, __v_3, __v_4, __v_6, __v_7]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_14, __v_1, __v_3, __v_4, __v_6, __v_7]; 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 __v_23: G = __r_arr[0];
     break '__mc_0 [__v_23];
   },
@@ -50553,21 +49996,21 @@ fn aiur_fn_581(
  };
             let __v_23: G = __mc_out___mc_0[0];
             let __v_24: G = G::from_u64(0);
-            let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_23, __v_5, __v_6, __v_24]; 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 __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_23, __v_5, __v_6, __v_24]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
             let __v_27: G = __r_arr[0];
-            let __ret: [G; OUT_581] = [__v_27];
-            record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_584] = [__v_27];
+            record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_581] = [__v_23];
-            record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_584] = [__v_23];
+            record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50579,15 +50022,15 @@ fn aiur_fn_581(
   })
 }
 
-const INPUT_SIZE_582: usize = 2;
-const IN_582: usize = 2;
-const OUT_582: usize = 1;
-fn aiur_fn_582(
-  inp: [G; IN_582],
+const INPUT_SIZE_585: usize = 2;
+const IN_585: usize = 2;
+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_582], ExecError> {
+) -> Result<[G; OUT_585], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50599,19 +50042,19 @@ fn aiur_fn_582(
     let __v_6: G = __loaded[4];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_582] = [__v_0];
-        record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_585] = [__v_0];
+        record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __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 __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_3, __v_4]; 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_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_6]; 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 __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_0, __v_6]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_582] = [__v_8];
-            record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_585] = [__v_8];
+            record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -50621,12 +50064,12 @@ fn aiur_fn_582(
             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 = { let __values: [G; 6] = [__v_8, __v_3, __v_9, __v_4, __v_5, __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 __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_14, __v_6]; 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 __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_14, __v_6]; 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_15: G = __r_arr[0];
-            let __ret: [G; OUT_582] = [__v_15];
-            record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_585] = [__v_15];
+            record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50638,15 +50081,15 @@ fn aiur_fn_582(
   })
 }
 
-const INPUT_SIZE_583: usize = 3;
-const IN_583: usize = 3;
-const OUT_583: usize = 1;
-fn aiur_fn_583(
-  inp: [G; IN_583],
+const INPUT_SIZE_586: usize = 3;
+const IN_586: usize = 3;
+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_583], ExecError> {
+) -> Result<[G; OUT_586], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50661,8 +50104,8 @@ fn aiur_fn_583(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_583] = [__v_9];
-        record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_586] = [__v_9];
+        record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -50674,25 +50117,25 @@ fn aiur_fn_583(
             match __v_5.as_canonical_u64() {
               0u64 => {
                 let __v_12: G = G::from_u64(1);
-                let __ret: [G; OUT_583] = [__v_12];
-                record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_586] = [__v_12];
+                record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_6, __v_2]; 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 __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_6, __v_2]; 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_12: G = __r_arr[0];
                 match __v_12.as_canonical_u64() {
                   1u64 => {
                     let __v_13: G = G::from_u64(1);
-                    let __ret: [G; OUT_583] = [__v_13];
-                    record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_586] = [__v_13];
+                    record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_8, __v_1, __v_2]; 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 __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_8, __v_1, __v_2]; 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_13: G = __r_arr[0];
-                    let __ret: [G; OUT_583] = [__v_13];
-                    record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_586] = [__v_13];
+                    record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -50703,10 +50146,10 @@ fn aiur_fn_583(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_8, __v_1, __v_2]; 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 __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_8, __v_1, __v_2]; 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_583] = [__v_12];
-            record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_586] = [__v_12];
+            record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50718,15 +50161,15 @@ fn aiur_fn_583(
   })
 }
 
-const INPUT_SIZE_584: usize = 2;
-const IN_584: usize = 2;
-const OUT_584: usize = 1;
-fn aiur_fn_584(
-  inp: [G; IN_584],
+const INPUT_SIZE_587: usize = 2;
+const IN_587: usize = 2;
+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_584], ExecError> {
+) -> Result<[G; OUT_587], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50743,14 +50186,14 @@ fn aiur_fn_584(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_584] = [__v_8];
-            record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_587] = [__v_8];
+            record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_584] = [__v_8];
-            record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_587] = [__v_8];
+            record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -50766,24 +50209,24 @@ fn aiur_fn_584(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_584] = [__v_8];
-            record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_587] = [__v_8];
+            record.function_queries[587].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_584] = { let __args: [G; IN_584] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_584] = [__v_9];
-                record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_587] = [__v_9];
+                record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_584] = [__v_9];
-                record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_587] = [__v_9];
+                record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -50800,15 +50243,15 @@ fn aiur_fn_584(
   })
 }
 
-const INPUT_SIZE_585: usize = 3;
-const IN_585: usize = 3;
-const OUT_585: usize = 1;
-fn aiur_fn_585(
-  inp: [G; IN_585],
+const INPUT_SIZE_588: usize = 3;
+const IN_588: usize = 3;
+const OUT_588: usize = 1;
+fn aiur_fn_588(
+  inp: [G; IN_588],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_585], ExecError> {
+) -> Result<[G; OUT_588], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50822,12 +50265,12 @@ fn aiur_fn_585(
         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_585] = [__v_8];
-        record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_588] = [__v_8];
+        record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -50844,18 +50287,18 @@ fn aiur_fn_585(
         match __v_7.as_canonical_u64() {
           5u64 => {
             let __v_18: G = G::from_u64(0);
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_8, __v_18]; 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 __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_1, __v_8, __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 __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_585] = { let __args: [G; IN_585] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_5, __v_1, __v_2]; 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 __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_585] = [__v_26];
-            record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_588] = [__v_26];
+            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -50867,11 +50310,11 @@ fn aiur_fn_585(
             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_585] = { let __args: [G; IN_585] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_5, __v_1, __v_2]; 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 __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_585] = [__v_27];
-            record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_588] = [__v_27];
+            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50883,15 +50326,15 @@ fn aiur_fn_585(
   })
 }
 
-const INPUT_SIZE_586: usize = 1;
-const IN_586: usize = 1;
-const OUT_586: usize = 1;
-fn aiur_fn_586(
-  inp: [G; IN_586],
+const INPUT_SIZE_589: usize = 1;
+const IN_589: usize = 1;
+const OUT_589: usize = 1;
+fn aiur_fn_589(
+  inp: [G; IN_589],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_586], ExecError> {
+) -> Result<[G; OUT_589], 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 };
@@ -50906,17 +50349,17 @@ fn aiur_fn_586(
         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_586] = [__v_9];
-        record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_589] = [__v_9];
+        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_6]; 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 __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_6]; 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 __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_586] = [__v_9];
-        record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_589] = [__v_9];
+        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -50926,15 +50369,15 @@ fn aiur_fn_586(
   })
 }
 
-const INPUT_SIZE_587: usize = 2;
-const IN_587: usize = 2;
-const OUT_587: usize = 4;
-fn aiur_fn_587(
-  inp: [G; IN_587],
+const INPUT_SIZE_590: usize = 2;
+const IN_590: usize = 2;
+const OUT_590: usize = 4;
+fn aiur_fn_590(
+  inp: [G; IN_590],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_587], ExecError> {
+) -> Result<[G; OUT_590], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50955,27 +50398,27 @@ fn aiur_fn_587(
         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_587] = [__v_8, __v_9, __v_12, __v_15];
-        record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_590] = [__v_8, __v_9, __v_12, __v_15];
+        record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_587] = [__v_3, __v_4, __v_5, __v_6];
-            record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_590] = [__v_3, __v_4, __v_5, __v_6];
+            record.function_queries[590].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_587] = { let __args: [G; IN_587] = [__v_7, __v_9]; 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 __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_7, __v_9]; 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_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_587] = [__v_10, __v_11, __v_12, __v_13];
-            record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_590] = [__v_10, __v_11, __v_12, __v_13];
+            record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50987,31 +50430,31 @@ fn aiur_fn_587(
   })
 }
 
-const INPUT_SIZE_588: usize = 4;
-const IN_588: usize = 4;
-const OUT_588: usize = 1;
-fn aiur_fn_588(
-  inp: [G; IN_588],
+const INPUT_SIZE_591: usize = 4;
+const IN_591: usize = 4;
+const OUT_591: usize = 1;
+fn aiur_fn_591(
+  inp: [G; IN_591],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_588], ExecError> {
+) -> Result<[G; OUT_591], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[784].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_784] = unsafe { *(result.output.as_ptr() as *const [G; OUT_784]) }; __ret } else { aiur_fn_784(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[787].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_787] = unsafe { *(result.output.as_ptr() as *const [G; OUT_787]) }; __ret } else { aiur_fn_787(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } else { aiur_fn_780(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } else { aiur_fn_783(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_6]; 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 __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_6]; 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_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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __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];
@@ -51027,16 +50470,16 @@ fn aiur_fn_588(
     let __v_22: G = __loaded[10];
     match __v_12.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_14, __v_15]; 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 __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_14, __v_15]; 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_23: G = __r_arr[0];
         let __v_24: G = __r_arr[1];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2]; 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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } else { aiur_fn_783(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[786].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_786] = unsafe { *(result.output.as_ptr() as *const [G; OUT_786]) }; __ret } else { aiur_fn_786(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = G::from_u64(0);
         let __v_28: G = G::from_u64(0);
-        let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_28, __v_26]; 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 __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_28, __v_26]; 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 __v_30: G = G::from_u64(1);
         let __v_31: G = G::from_u64(1);
@@ -51044,36 +50487,36 @@ fn aiur_fn_588(
         let __v_33: G = { let __values: [G; 3] = [__v_27, __v_29, __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(1);
         let __v_35: G = (__v_26 + __v_34);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_33, __v_5, __v_10, __v_15, __v_23, __v_25, __v_2, __v_3, __v_35]; 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 __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_33, __v_5, __v_10, __v_15, __v_23, __v_25, __v_2, __v_3, __v_35]; 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_36: G = __r_arr[0];
-        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_36]; 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 __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_37, __v_5]; 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_593] = { let __args: [G; IN_593] = [__v_37, __v_5]; 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_4, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
         let __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_588] = [__v_39];
-        record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_591] = [__v_39];
+        record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_588] = [__v_0];
-        record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_591] = [__v_0];
+        record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_589: usize = 2;
-const IN_589: usize = 2;
-const OUT_589: usize = 1;
-fn aiur_fn_589(
-  inp: [G; IN_589],
+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_589], ExecError> {
+) -> Result<[G; OUT_592], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51083,34 +50526,34 @@ fn aiur_fn_589(
         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_589] = [__v_5];
-        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_592] = [__v_5];
+        record.function_queries[592].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_0 + __v_4);
-        let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __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_6: G = __r_arr[0];
         let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_589] = [__v_7];
-        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_592] = [__v_7];
+        record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_590: usize = 2;
-const IN_590: usize = 2;
-const OUT_590: usize = 1;
-fn aiur_fn_590(
-  inp: [G; IN_590],
+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_590], ExecError> {
+) -> Result<[G; OUT_593], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51123,22 +50566,22 @@ 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; 6] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_590] = [__v_7];
-        record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_593] = [__v_7];
+        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_1, __v_3]; 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_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 __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_4, __v_1]; 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_593] = { let __args: [G; IN_593] = [__v_4, __v_1]; 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 __v_11: G = { let __values: [G; 6] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_590] = [__v_11];
-        record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_593] = [__v_11];
+        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51148,15 +50591,15 @@ fn aiur_fn_590(
   })
 }
 
-const INPUT_SIZE_591: usize = 9;
-const IN_591: usize = 9;
-const OUT_591: usize = 1;
-fn aiur_fn_591(
-  inp: [G; IN_591],
+const INPUT_SIZE_594: usize = 9;
+const IN_594: usize = 9;
+const OUT_594: usize = 1;
+fn aiur_fn_594(
+  inp: [G; IN_594],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_591], ExecError> {
+) -> Result<[G; OUT_594], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51169,31 +50612,31 @@ fn aiur_fn_591(
     let __v_8: G = inp[8];
     match __v_8.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_591] = [__v_0];
-        record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_594] = [__v_0];
+        record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_5, __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 __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_0, __v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_0, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_11]; 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 __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0, __v_11]; 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_12: G = __r_arr[0];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_591] = [__v_0];
-            record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_594] = [__v_0];
+            record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(1);
             let __v_14: G = (__v_8 - __v_13);
-            let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_14]; 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 __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_14]; 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_15: G = __r_arr[0];
-            let __ret: [G; OUT_591] = [__v_15];
-            record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_594] = [__v_15];
+            record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -51202,15 +50645,15 @@ fn aiur_fn_591(
   })
 }
 
-const INPUT_SIZE_592: usize = 3;
-const IN_592: usize = 3;
-const OUT_592: usize = 1;
-fn aiur_fn_592(
-  inp: [G; IN_592],
+const INPUT_SIZE_595: usize = 3;
+const IN_595: usize = 3;
+const OUT_595: usize = 1;
+fn aiur_fn_595(
+  inp: [G; IN_595],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_592], ExecError> {
+) -> Result<[G; OUT_595], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51224,21 +50667,21 @@ fn aiur_fn_592(
         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_592] = [__v_8];
-        record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_595] = [__v_8];
+        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1, __v_2]; 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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_2 + __v_7);
-        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_1, __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 __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } else { aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_592] = [__v_10];
-        record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_595] = [__v_10];
+        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51248,15 +50691,15 @@ fn aiur_fn_592(
   })
 }
 
-const INPUT_SIZE_593: usize = 3;
-const IN_593: usize = 3;
-const OUT_593: usize = 1;
-fn aiur_fn_593(
-  inp: [G; IN_593],
+const INPUT_SIZE_596: usize = 3;
+const IN_596: usize = 3;
+const OUT_596: usize = 1;
+fn aiur_fn_596(
+  inp: [G; IN_596],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_593], ExecError> {
+) -> Result<[G; OUT_596], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51270,18 +50713,18 @@ fn aiur_fn_593(
         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_593] = [__v_8];
-        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_596] = [__v_8];
+        record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = (__v_1 + __v_4);
-        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1, __v_2]; 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_8: G = __r_arr[0];
         let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_2, __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_593] = [__v_9];
-        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_596] = [__v_9];
+        record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51291,15 +50734,15 @@ fn aiur_fn_593(
   })
 }
 
-const INPUT_SIZE_594: usize = 9;
-const IN_594: usize = 9;
-const OUT_594: usize = 1;
-fn aiur_fn_594(
-  inp: [G; IN_594],
+const INPUT_SIZE_597: usize = 9;
+const IN_597: usize = 9;
+const OUT_597: usize = 1;
+fn aiur_fn_597(
+  inp: [G; IN_597],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_594], ExecError> {
+) -> Result<[G; OUT_597], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51319,19 +50762,19 @@ fn aiur_fn_594(
         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_594] = [__v_14];
-        record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_597] = [__v_14];
+        record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_594] = [__v_14];
-        record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_597] = [__v_14];
+        record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51341,15 +50784,15 @@ fn aiur_fn_594(
   })
 }
 
-const INPUT_SIZE_595: usize = 9;
-const IN_595: usize = 9;
-const OUT_595: usize = 1;
-fn aiur_fn_595(
-  inp: [G; IN_595],
+const INPUT_SIZE_598: usize = 9;
+const IN_598: usize = 9;
+const OUT_598: usize = 1;
+fn aiur_fn_598(
+  inp: [G; IN_598],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_595], ExecError> {
+) -> Result<[G; OUT_598], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51360,15 +50803,15 @@ fn aiur_fn_595(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_9: G = __r_arr[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_595] = [__v_12];
-        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_598] = [__v_12];
+        record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -51377,32 +50820,32 @@ fn aiur_fn_595(
         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_10, __v_0, __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_595] = [__v_14];
-        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_598] = [__v_14];
+        record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__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[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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__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[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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_11: G = __r_arr[0];
-        let __ret: [G; OUT_595] = [__v_11];
-        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_598] = [__v_11];
+        record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_596: usize = 9;
-const IN_596: usize = 9;
-const OUT_596: usize = 1;
-fn aiur_fn_596(
-  inp: [G; IN_596],
+const INPUT_SIZE_599: usize = 9;
+const IN_599: usize = 9;
+const OUT_599: usize = 1;
+fn aiur_fn_599(
+  inp: [G; IN_599],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_596], ExecError> {
+) -> Result<[G; OUT_599], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51422,17 +50865,17 @@ fn aiur_fn_596(
         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_596] = [__v_14];
-        record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_599] = [__v_14];
+        record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_10, __v_12, __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[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_10, __v_12, __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[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_13: G = __r_arr[0];
-        let __ret: [G; OUT_596] = [__v_13];
-        record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_599] = [__v_13];
+        record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51442,15 +50885,15 @@ fn aiur_fn_596(
   })
 }
 
-const INPUT_SIZE_597: usize = 10;
-const IN_597: usize = 10;
-const OUT_597: usize = 1;
-fn aiur_fn_597(
-  inp: [G; IN_597],
+const INPUT_SIZE_600: usize = 10;
+const IN_600: usize = 10;
+const OUT_600: usize = 1;
+fn aiur_fn_600(
+  inp: [G; IN_600],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_597], ExecError> {
+) -> Result<[G; OUT_600], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51473,29 +50916,29 @@ fn aiur_fn_597(
         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 = { let __values: [G; 3] = [__v_13, __v_0, __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_597] = [__v_17];
-        record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_600] = [__v_17];
+        record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_11, __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[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 __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_11, __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[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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
         match __v_13.as_canonical_u64() {
           2u64 => {
             let __v_15: G = G::from_u64(0);
-            let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 = { let __values: [G; 3] = [__v_15, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_597] = [__v_17];
-            record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_600] = [__v_17];
+            record.function_queries[600].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; 3] = [__v_15, __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_597] = [__v_16];
-            record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_600] = [__v_16];
+            record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -51507,15 +50950,15 @@ fn aiur_fn_597(
   })
 }
 
-const INPUT_SIZE_598: usize = 9;
-const IN_598: usize = 9;
-const OUT_598: usize = 1;
-fn aiur_fn_598(
-  inp: [G; IN_598],
+const INPUT_SIZE_601: usize = 9;
+const IN_601: usize = 9;
+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_598], ExecError> {
+) -> Result<[G; OUT_601], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51535,8 +50978,8 @@ fn aiur_fn_598(
         let __v_12: G = G::from_u64(1);
         let __v_13: G = G::from_u64(1);
         let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_598] = [__v_14];
-        record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_601] = [__v_14];
+        record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -51545,10 +50988,10 @@ fn aiur_fn_598(
         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 = { let __values: [G; 3] = [__v_12, __v_10, __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_599] = { let __args: [G; IN_599] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __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 __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_16]; 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_17: G = __r_arr[0];
-        let __ret: [G; OUT_598] = [__v_17];
-        record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_601] = [__v_17];
+        record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51558,15 +51001,15 @@ fn aiur_fn_598(
   })
 }
 
-const INPUT_SIZE_599: usize = 11;
-const IN_599: usize = 11;
-const OUT_599: usize = 1;
-fn aiur_fn_599(
-  inp: [G; IN_599],
+const INPUT_SIZE_602: usize = 11;
+const IN_602: usize = 11;
+const OUT_602: usize = 1;
+fn aiur_fn_602(
+  inp: [G; IN_602],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_599], ExecError> {
+) -> Result<[G; OUT_602], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51590,22 +51033,22 @@ fn aiur_fn_599(
         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_10, __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_599] = [__v_18];
-        record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_602] = [__v_18];
+        record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_9, __v_12, __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[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 __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_12, __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[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 __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12, __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 __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12, __v_16]; 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_17: G = __r_arr[0];
-            let __ret: [G; OUT_599] = [__v_17];
-            record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_602] = [__v_17];
+            record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -51615,11 +51058,11 @@ fn aiur_fn_599(
             let __v_19: G = G::from_u64(1);
             let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_21: G = { let __values: [G; 3] = [__v_17, __v_12, __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_599] = { let __args: [G; IN_599] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12, __v_21]; 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 __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12, __v_21]; 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_22: G = __r_arr[0];
             let __v_23: G = { let __values: [G; 3] = [__v_16, __v_10, __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_599] = [__v_23];
-            record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_602] = [__v_23];
+            record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -51631,15 +51074,15 @@ fn aiur_fn_599(
   })
 }
 
-const INPUT_SIZE_600: usize = 10;
-const IN_600: usize = 10;
-const OUT_600: usize = 2;
-fn aiur_fn_600(
-  inp: [G; IN_600],
+const INPUT_SIZE_603: usize = 10;
+const IN_603: usize = 10;
+const OUT_603: usize = 2;
+fn aiur_fn_603(
+  inp: [G; IN_603],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_600], ExecError> {
+) -> Result<[G; OUT_603], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51651,17 +51094,17 @@ fn aiur_fn_600(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_3, __v_0]; 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 __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_3, __v_0]; 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
     let __v_13: G = __r_arr[3];
-    let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_3, __v_1]; 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_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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_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];
@@ -51675,7 +51118,7 @@ fn aiur_fn_600(
     let __v_27: G = __loaded[8];
     let __v_28: G = __loaded[9];
     let __v_29: G = __loaded[10];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_8, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_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];
@@ -51693,74 +51136,74 @@ fn aiur_fn_600(
       5u64 => {
         match __v_31.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_23, __v_35]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_23, __v_35]; 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_42: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_42]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_42]; 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_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_24]; 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_45: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_36]; 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_46: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_45, __v_46]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_45, __v_46]; 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_47: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_47]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_47]; 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_48: G = __r_arr[0];
             let __v_49: G = __r_arr[1];
-            let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_21, __v_22, __v_12, __v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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 __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_21, __v_22, __v_12, __v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_50: G = __r_arr[0];
-            let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_33, __v_34, __v_16, __v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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 __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_33, __v_34, __v_16, __v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_51: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_50, __v_51, __v_2, __v_9]; 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_652] = { let __args: [G; IN_652] = [__v_50, __v_51, __v_2, __v_9]; 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_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
-            let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_24, __v_22, __v_12, __v_13, __v_36, __v_34, __v_16, __v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9]; 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 __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_24, __v_22, __v_12, __v_13, __v_36, __v_34, __v_16, __v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9]; 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_54: G = __r_arr[0];
             let __v_55: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_52, __v_53, __v_54, __v_55]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_52, __v_53, __v_54, __v_55]; 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_56: G = __r_arr[0];
             let __v_57: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_48, __v_49, __v_56, __v_57]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_48, __v_49, __v_56, __v_57]; 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_58: G = __r_arr[0];
             let __v_59: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_43, __v_44, __v_58, __v_59]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_43, __v_44, __v_58, __v_59]; 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_60: G = __r_arr[0];
             let __v_61: G = __r_arr[1];
-            let __ret: [G; OUT_600] = [__v_60, __v_61];
-            record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_603] = [__v_60, __v_61];
+            record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = []; 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = []; 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_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
-            let __ret: [G; OUT_600] = [__v_42, __v_43];
-            record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_603] = [__v_42, __v_43];
+            record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = []; 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = []; 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_42: G = __r_arr[0];
         let __v_43: G = __r_arr[1];
-        let __ret: [G; OUT_600] = [__v_42, __v_43];
-        record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_603] = [__v_42, __v_43];
+        record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_601: usize = 11;
-const IN_601: usize = 11;
-const OUT_601: usize = 1;
-fn aiur_fn_601(
-  inp: [G; IN_601],
+const INPUT_SIZE_604: usize = 11;
+const IN_604: usize = 11;
+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_601], ExecError> {
+) -> Result<[G; OUT_604], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51773,31 +51216,31 @@ fn aiur_fn_601(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_3]; 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_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_11, __v_1, __v_2, __v_12, __v_9, __v_10]; 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 __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_11, __v_1, __v_2, __v_12, __v_9, __v_10]; 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_13: G = __r_arr[0];
     let __v_14: G = G::from_u64(0);
-    let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_13, __v_4, __v_5, __v_6, __v_8, __v_14]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_13, __v_4, __v_5, __v_6, __v_8, __v_14]; 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_15, __v_7]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_15, __v_7]; 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_16: G = __r_arr[0];
-    let __ret: [G; OUT_601] = [__v_16];
-    record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_604] = [__v_16];
+    record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_602: usize = 16;
-const IN_602: usize = 16;
-const OUT_602: usize = 2;
-fn aiur_fn_602(
-  inp: [G; IN_602],
+const INPUT_SIZE_605: usize = 16;
+const IN_605: usize = 16;
+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_602], ExecError> {
+) -> Result<[G; OUT_605], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51821,11 +51264,11 @@ fn aiur_fn_602(
     let __v_18: G = __loaded[2];
     match __v_16.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = []; 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = []; 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __ret: [G; OUT_602] = [__v_19, __v_20];
-        record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_605] = [__v_19, __v_20];
+        record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -51835,15 +51278,15 @@ fn aiur_fn_602(
         let __v_21: G = __loaded[2];
         match __v_19.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = []; 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = []; 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_22: G = __r_arr[0];
             let __v_23: G = __r_arr[1];
-            let __ret: [G; OUT_602] = [__v_22, __v_23];
-            record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_605] = [__v_22, __v_23];
+            record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_22: 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_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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
             let __v_23: G = __loaded[0];
@@ -51857,7 +51300,7 @@ fn aiur_fn_602(
             let __v_31: G = __loaded[8];
             let __v_32: G = __loaded[9];
             let __v_33: G = __loaded[10];
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_14, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_14, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_34: G = __r_arr[0];
             let __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];
@@ -51875,47 +51318,47 @@ fn aiur_fn_602(
               6u64 => {
                 match __v_35.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_29, __v_41]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_29, __v_41]; 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_46: G = __r_arr[0];
-                    let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_46]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_46]; 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_47: G = __r_arr[0];
                     let __v_48: G = __r_arr[1];
-                    let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_25, __v_1, __v_2, __v_3, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_15]; 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 __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_25, __v_1, __v_2, __v_3, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __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_49: G = __r_arr[0];
-                    let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_37, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_15]; 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 __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_37, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __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_50: G = __r_arr[0];
-                    let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_49, __v_50, __v_13, __v_15]; 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_652] = { let __args: [G; IN_652] = [__v_49, __v_50, __v_13, __v_15]; 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_51: G = __r_arr[0];
                     let __v_52: G = __r_arr[1];
-                    let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_18, __v_1, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; 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 __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_18, __v_1, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; 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_53: G = __r_arr[0];
                     let __v_54: G = __r_arr[1];
-                    let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_51, __v_52, __v_53, __v_54]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_51, __v_52, __v_53, __v_54]; 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_55: G = __r_arr[0];
                     let __v_56: G = __r_arr[1];
-                    let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_47, __v_48, __v_55, __v_56]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_47, __v_48, __v_55, __v_56]; 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_57: G = __r_arr[0];
                     let __v_58: G = __r_arr[1];
-                    let __ret: [G; OUT_602] = [__v_57, __v_58];
-                    record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_605] = [__v_57, __v_58];
+                    record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = []; 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = []; 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_46: G = __r_arr[0];
                     let __v_47: G = __r_arr[1];
-                    let __ret: [G; OUT_602] = [__v_46, __v_47];
-                    record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_605] = [__v_46, __v_47];
+                    record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = []; 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = []; 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_46: G = __r_arr[0];
                 let __v_47: G = __r_arr[1];
-                let __ret: [G; OUT_602] = [__v_46, __v_47];
-                record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_605] = [__v_46, __v_47];
+                record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -51932,15 +51375,15 @@ fn aiur_fn_602(
   })
 }
 
-const INPUT_SIZE_603: usize = 11;
-const IN_603: usize = 11;
-const OUT_603: usize = 1;
-fn aiur_fn_603(
-  inp: [G; IN_603],
+const INPUT_SIZE_606: usize = 11;
+const IN_606: usize = 11;
+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_603], ExecError> {
+) -> Result<[G; OUT_606], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51953,28 +51396,28 @@ fn aiur_fn_603(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_1, __v_2, __v_3, __v_9, __v_10]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0, __v_1, __v_2, __v_3, __v_9, __v_10]; 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 __v_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_11, __v_4, __v_5, __v_6, __v_8, __v_12]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_11, __v_4, __v_5, __v_6, __v_8, __v_12]; 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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_7]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_13, __v_7]; 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_14: G = __r_arr[0];
-    let __ret: [G; OUT_603] = [__v_14];
-    record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_606] = [__v_14];
+    record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_604: usize = 6;
-const IN_604: usize = 6;
-const OUT_604: usize = 1;
-fn aiur_fn_604(
-  inp: [G; IN_604],
+const INPUT_SIZE_607: usize = 6;
+const IN_607: usize = 6;
+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_604], ExecError> {
+) -> Result<[G; OUT_607], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51982,13 +51425,13 @@ fn aiur_fn_604(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_604] = [__v_7];
-        record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_607] = [__v_7];
+        record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -52000,71 +51443,71 @@ fn aiur_fn_604(
         match __v_8.as_canonical_u64() {
           3u64 => {
             let __v_12: G = G::from_u64(3);
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_14: G = __r_arr[0];
             let __v_15: G = G::from_u64(0);
             let __v_16: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_604] = [__v_16];
-            record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_607] = [__v_16];
+            record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             let __v_12: G = G::from_u64(4);
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_13: G = __r_arr[0];
             let __v_14: G = G::from_u64(1);
             let __v_15: G = (__v_5 + __v_14);
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_15]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_15]; 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_16: G = __r_arr[0];
             let __v_17: G = G::from_u64(0);
             let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __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_604] = [__v_18];
-            record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_607] = [__v_18];
+            record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
             let __v_12: G = G::from_u64(5);
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_13: G = __r_arr[0];
             let __v_14: G = G::from_u64(1);
             let __v_15: G = (__v_5 + __v_14);
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_15]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_15]; 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_16: G = __r_arr[0];
             let __v_17: G = G::from_u64(0);
             let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __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_604] = [__v_18];
-            record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_607] = [__v_18];
+            record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
             let __v_12: G = G::from_u64(6);
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_14: G = __r_arr[0];
             let __v_15: G = G::from_u64(1);
             let __v_16: G = (__v_5 + __v_15);
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_16]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_16]; 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_17: G = __r_arr[0];
             let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_604] = [__v_18];
-            record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_607] = [__v_18];
+            record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           8u64 => {
             let __v_12: G = G::from_u64(8);
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_13: G = __r_arr[0];
             let __v_14: G = { let __values: [G; 4] = [__v_12, __v_9, __v_10, __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_604] = [__v_14];
-            record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_607] = [__v_14];
+            record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_604] = [__v_0];
-            record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_607] = [__v_0];
+            record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52073,15 +51516,15 @@ fn aiur_fn_604(
   })
 }
 
-const INPUT_SIZE_605: usize = 6;
-const IN_605: usize = 6;
-const OUT_605: usize = 2;
-fn aiur_fn_605(
-  inp: [G; IN_605],
+const INPUT_SIZE_608: usize = 6;
+const IN_608: usize = 6;
+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_605], ExecError> {
+) -> Result<[G; OUT_608], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52089,7 +51532,7 @@ fn aiur_fn_605(
     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_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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_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 };
@@ -52100,32 +51543,32 @@ fn aiur_fn_605(
     match __v_8.as_canonical_u64() {
       2u64 => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_9, __v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_12]; 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 __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_0, __v_9, __v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_12]; 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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_605] = [__v_13, __v_14];
-        record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_608] = [__v_13, __v_14];
+        record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_605] = [__v_12, __v_0];
-        record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_608] = [__v_12, __v_0];
+        record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_606: usize = 9;
-const IN_606: usize = 9;
-const OUT_606: usize = 2;
-fn aiur_fn_606(
-  inp: [G; IN_606],
+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_606], ExecError> {
+) -> Result<[G; OUT_609], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52146,42 +51589,42 @@ fn aiur_fn_606(
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_15: G = G::from_u64(0);
-        let __ret: [G; OUT_606] = [__v_15, __v_0];
-        record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_609] = [__v_15, __v_0];
+        record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_15: G = (__v_10 - __v_1);
         match __v_15.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_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_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2]; 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_17: G = __r_arr[0];
             let __v_18: G = { let __a_val = __v_17.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_18.as_canonical_u64() {
               1u64 => {
                 let __v_19: G = G::from_u64(1);
                 let __v_20: G = (__v_8 + __v_19);
-                let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_14, __v_4, __v_5, __v_6, __v_7, __v_20]; 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 __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_0, __v_1, __v_2, __v_14, __v_4, __v_5, __v_6, __v_7, __v_20]; 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_21: G = __r_arr[0];
                 let __v_22: G = __r_arr[1];
-                let __ret: [G; OUT_606] = [__v_21, __v_22];
-                record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_609] = [__v_21, __v_22];
+                record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_12, __v_7]; 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 __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_2, __v_12, __v_7]; 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_19: G = __r_arr[0];
                 match __v_19.as_canonical_u64() {
                   0u64 => {
                     let __v_20: G = G::from_u64(1);
                     let __v_21: G = (__v_8 + __v_20);
-                    let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_14, __v_4, __v_5, __v_6, __v_7, __v_21]; 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 __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_0, __v_1, __v_2, __v_14, __v_4, __v_5, __v_6, __v_7, __v_21]; 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_22: G = __r_arr[0];
                     let __v_23: G = __r_arr[1];
-                    let __ret: [G; OUT_606] = [__v_22, __v_23];
-                    record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_609] = [__v_22, __v_23];
+                    record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
@@ -52190,15 +51633,15 @@ fn aiur_fn_606(
                     let __v_22: G = G::from_u64(0);
                     let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __v_24: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_23, __v_5, __v_7, __v_24]; 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 __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_23, __v_5, __v_7, __v_24]; 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_25: G = __r_arr[0];
                     let __v_26: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__args, record, io_buffer, __cu)? } };
                     let __v_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_25, __v_27]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_25, __v_27]; 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_28: G = __r_arr[0];
-                    let __ret: [G; OUT_606] = [__v_26, __v_28];
-                    record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_609] = [__v_26, __v_28];
+                    record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -52214,11 +51657,11 @@ fn aiur_fn_606(
           _ => {
             let __v_16: G = G::from_u64(1);
             let __v_17: G = (__v_8 + __v_16);
-            let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_14, __v_4, __v_5, __v_6, __v_7, __v_17]; 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 __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_0, __v_1, __v_2, __v_14, __v_4, __v_5, __v_6, __v_7, __v_17]; 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_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_606] = [__v_18, __v_19];
-            record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_609] = [__v_18, __v_19];
+            record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52230,15 +51673,15 @@ fn aiur_fn_606(
   })
 }
 
-const INPUT_SIZE_607: usize = 3;
-const IN_607: usize = 3;
-const OUT_607: usize = 1;
-fn aiur_fn_607(
-  inp: [G; IN_607],
+const INPUT_SIZE_610: usize = 3;
+const IN_610: usize = 3;
+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_607], ExecError> {
+) -> Result<[G; OUT_610], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52250,8 +51693,8 @@ fn aiur_fn_607(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_607] = [__v_6];
-        record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_610] = [__v_6];
+        record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -52262,28 +51705,28 @@ fn aiur_fn_607(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_607] = [__v_9];
-            record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_610] = [__v_9];
+            record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_2, __v_9]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __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 __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_7, __v_10]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_7, __v_10]; 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 __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_8, __v_5, __v_2]; 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 __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_8, __v_5, __v_2]; 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_12: G = __r_arr[0];
-                let __ret: [G; OUT_607] = [__v_12];
-                record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_610] = [__v_12];
+                record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_607] = [__v_12];
-                record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_610] = [__v_12];
+                record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -52300,15 +51743,15 @@ fn aiur_fn_607(
   })
 }
 
-const INPUT_SIZE_608: usize = 4;
-const IN_608: usize = 4;
-const OUT_608: usize = 1;
-fn aiur_fn_608(
-  inp: [G; IN_608],
+const INPUT_SIZE_611: usize = 4;
+const IN_611: usize = 4;
+const OUT_611: usize = 1;
+fn aiur_fn_611(
+  inp: [G; IN_611],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_608], ExecError> {
+) -> Result<[G; OUT_611], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52317,8 +51760,8 @@ fn aiur_fn_608(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_608] = [__v_0];
-        record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_611] = [__v_0];
+        record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -52334,25 +51777,25 @@ fn aiur_fn_608(
         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_608] = { let __args: [G; IN_608] = [__v_14, __v_1, __v_2, __v_16]; 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 __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_14, __v_1, __v_2, __v_16]; 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_17: G = __r_arr[0];
-        let __ret: [G; OUT_608] = [__v_17];
-        record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_611] = [__v_17];
+        record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_609: usize = 6;
-const IN_609: usize = 6;
-const OUT_609: usize = 1;
-fn aiur_fn_609(
-  inp: [G; IN_609],
+const INPUT_SIZE_612: usize = 6;
+const IN_612: usize = 6;
+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_609], ExecError> {
+) -> Result<[G; OUT_612], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52363,32 +51806,32 @@ fn aiur_fn_609(
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_6]; 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 __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1, __v_2, __v_6]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_609] = [__v_7];
-        record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_612] = [__v_7];
+        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_5, __v_3]; 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 __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_0, __v_5, __v_3]; 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_609] = [__v_6];
-        record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_612] = [__v_6];
+        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_610: usize = 2;
-const IN_610: usize = 2;
-const OUT_610: usize = 1;
-fn aiur_fn_610(
-  inp: [G; IN_610],
+const INPUT_SIZE_613: usize = 2;
+const IN_613: usize = 2;
+const OUT_613: usize = 1;
+fn aiur_fn_613(
+  inp: [G; IN_613],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_610], ExecError> {
+) -> Result<[G; OUT_613], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52404,12 +51847,12 @@ fn aiur_fn_610(
         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_610] = [__v_10];
-        record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_613] = [__v_10];
+        record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __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];
@@ -52426,21 +51869,21 @@ fn aiur_fn_610(
         match __v_9.as_canonical_u64() {
           5u64 => {
             let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_7, __v_1]; 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 __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_7, __v_1]; 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_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_610] = [__v_22];
-            record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_613] = [__v_22];
+            record.function_queries[613].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_610] = { let __args: [G; IN_610] = [__v_7, __v_1]; 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 __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_7, __v_1]; 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_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_610] = [__v_23];
-            record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_613] = [__v_23];
+            record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52452,15 +51895,15 @@ fn aiur_fn_610(
   })
 }
 
-const INPUT_SIZE_611: usize = 3;
-const IN_611: usize = 3;
-const OUT_611: usize = 1;
-fn aiur_fn_611(
-  inp: [G; IN_611],
+const INPUT_SIZE_614: usize = 3;
+const IN_614: usize = 3;
+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_611], ExecError> {
+) -> Result<[G; OUT_614], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52498,28 +51941,28 @@ fn aiur_fn_611(
     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_126] = { let __args: [G; IN_126] = [__v_1, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1, __v_35]; 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_36: G = __r_arr[0];
     match __v_36.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_611] = [__v_0];
-        record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_614] = [__v_0];
+        record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_37: G = G::from_u64(0);
-        let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_1, __v_2, __v_2, __v_37]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_1, __v_2, __v_2, __v_37]; 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_38: G = __r_arr[0];
         let __v_39: G = __r_arr[1];
         match __v_38.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_611] = [__v_39];
-            record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_614] = [__v_39];
+            record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_611] = [__v_0];
-            record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_614] = [__v_0];
+            record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52531,20 +51974,20 @@ fn aiur_fn_611(
   })
 }
 
-const INPUT_SIZE_612: usize = 3;
-const IN_612: usize = 3;
-const OUT_612: usize = 1;
-fn aiur_fn_612(
-  inp: [G; IN_612],
+const INPUT_SIZE_615: usize = 3;
+const IN_615: usize = 3;
+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_612], ExecError> {
+) -> Result<[G; OUT_615], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0, __v_1, __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 __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } else { aiur_fn_620(__args, record, io_buffer, __cu)? } };
     let __v_3: 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_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: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
@@ -52555,29 +51998,29 @@ fn aiur_fn_612(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_612] = [__v_9];
-        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_615] = [__v_9];
+        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_9: G = G::from_u64(1);
-        let __ret: [G; OUT_612] = [__v_9];
-        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_615] = [__v_9];
+        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_613: usize = 3;
-const IN_613: usize = 3;
-const OUT_613: usize = 1;
-fn aiur_fn_613(
-  inp: [G; IN_613],
+const INPUT_SIZE_616: usize = 3;
+const IN_616: usize = 3;
+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_613], ExecError> {
+) -> Result<[G; OUT_616], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52589,25 +52032,25 @@ fn aiur_fn_613(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_613] = [__v_6];
-        record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_616] = [__v_6];
+        record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_4, __v_1, __v_2]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_613] = [__v_7];
-            record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_616] = [__v_7];
+            record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_5, __v_1, __v_2]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_613] = [__v_7];
-            record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_616] = [__v_7];
+            record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -52622,37 +52065,37 @@ fn aiur_fn_613(
   })
 }
 
-const INPUT_SIZE_614: usize = 2;
-const IN_614: usize = 2;
-const OUT_614: usize = 1;
-fn aiur_fn_614(
-  inp: [G; IN_614],
+const INPUT_SIZE_617: usize = 2;
+const IN_617: usize = 2;
+const OUT_617: usize = 1;
+fn aiur_fn_617(
+  inp: [G; IN_617],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_614], ExecError> {
+) -> Result<[G; OUT_617], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_2, __v_1]; 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 __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_2, __v_2, __v_1]; 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_3: G = __r_arr[0];
-    let __ret: [G; OUT_614] = [__v_3];
-    record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_617] = [__v_3];
+    record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_615: usize = 4;
-const IN_615: usize = 4;
-const OUT_615: usize = 2;
-fn aiur_fn_615(
-  inp: [G; IN_615],
+const INPUT_SIZE_618: usize = 4;
+const IN_618: usize = 4;
+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_615], ExecError> {
+) -> Result<[G; OUT_618], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52666,8 +52109,8 @@ fn aiur_fn_615(
       1u64 => {
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_615] = [__v_7, __v_8];
-        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_618] = [__v_7, __v_8];
+        record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -52685,23 +52128,23 @@ fn aiur_fn_615(
         let __v_17: G = __loaded[10];
         match __v_7.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_17, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_17, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
             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_615] = { let __args: [G; IN_615] = [__v_0, __v_6, __v_2, __v_20]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_0, __v_6, __v_2, __v_20]; 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_21: G = __r_arr[0];
                 let __v_22: G = __r_arr[1];
-                let __ret: [G; OUT_615] = [__v_21, __v_22];
-                record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_618] = [__v_21, __v_22];
+                record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; 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 __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; 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_19: G = __r_arr[0];
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_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];
@@ -52717,23 +52160,23 @@ fn aiur_fn_615(
                 let __v_31: G = __loaded[10];
                 match __v_21.as_canonical_u64() {
                   5u64 => {
-                    let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_19, __v_2]; 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 __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_19, __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_32: G = __r_arr[0];
                     match __v_32.as_canonical_u64() {
                       0u64 => {
                         let __v_33: G = G::from_u64(1);
                         let __v_34: G = (__v_3 + __v_33);
-                        let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_0, __v_6, __v_2, __v_34]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_0, __v_6, __v_2, __v_34]; 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_35: G = __r_arr[0];
                         let __v_36: G = __r_arr[1];
-                        let __ret: [G; OUT_615] = [__v_35, __v_36];
-                        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_618] = [__v_35, __v_36];
+                        record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_33: G = G::from_u64(1);
-                        let __ret: [G; OUT_615] = [__v_33, __v_19];
-                        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_618] = [__v_33, __v_19];
+                        record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -52741,11 +52184,11 @@ fn aiur_fn_615(
                   _ => {
                     let __v_32: G = G::from_u64(1);
                     let __v_33: G = (__v_3 + __v_32);
-                    let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_0, __v_6, __v_2, __v_33]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_0, __v_6, __v_2, __v_33]; 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_34: G = __r_arr[0];
                     let __v_35: G = __r_arr[1];
-                    let __ret: [G; OUT_615] = [__v_34, __v_35];
-                    record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_618] = [__v_34, __v_35];
+                    record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -52758,11 +52201,11 @@ fn aiur_fn_615(
           _ => {
             let __v_18: G = G::from_u64(1);
             let __v_19: G = (__v_3 + __v_18);
-            let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_0, __v_6, __v_2, __v_19]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_0, __v_6, __v_2, __v_19]; 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_20: G = __r_arr[0];
             let __v_21: G = __r_arr[1];
-            let __ret: [G; OUT_615] = [__v_20, __v_21];
-            record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_618] = [__v_20, __v_21];
+            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52774,15 +52217,15 @@ fn aiur_fn_615(
   })
 }
 
-const INPUT_SIZE_616: usize = 4;
-const IN_616: usize = 4;
-const OUT_616: usize = 1;
-fn aiur_fn_616(
-  inp: [G; IN_616],
+const INPUT_SIZE_619: usize = 4;
+const IN_619: usize = 4;
+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_616], ExecError> {
+) -> Result<[G; OUT_619], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52790,8 +52233,8 @@ fn aiur_fn_616(
     let __v_3: G = inp[3];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_616] = [__v_3];
-        record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_619] = [__v_3];
+        record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -52801,12 +52244,12 @@ fn aiur_fn_616(
         let __v_6: G = __loaded[2];
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_616] = [__v_3];
-            record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_619] = [__v_3];
+            record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __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];
@@ -52824,22 +52267,22 @@ fn aiur_fn_616(
               5u64 => {
                 let __v_19: G = G::from_u64(1);
                 let __v_20: G = (__v_1 - __v_19);
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_13]; 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_21: G = __r_arr[0];
                 let __v_22: G = (__v_3 + __v_21);
-                let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_6, __v_20, __v_2, __v_22]; 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 __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_6, __v_20, __v_2, __v_22]; 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 __ret: [G; OUT_616] = [__v_23];
-                record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_619] = [__v_23];
+                record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_19: G = G::from_u64(1);
                 let __v_20: G = (__v_1 - __v_19);
-                let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_6, __v_20, __v_2, __v_3]; 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 __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_6, __v_20, __v_2, __v_3]; 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_21: G = __r_arr[0];
-                let __ret: [G; OUT_616] = [__v_21];
-                record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_619] = [__v_21];
+                record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -52853,20 +52296,20 @@ fn aiur_fn_616(
   })
 }
 
-const INPUT_SIZE_617: usize = 3;
-const IN_617: usize = 3;
-const OUT_617: usize = 1;
-fn aiur_fn_617(
-  inp: [G; IN_617],
+const INPUT_SIZE_620: usize = 3;
+const IN_620: usize = 3;
+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_617], ExecError> {
+) -> Result<[G; OUT_620], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __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];
@@ -52882,33 +52325,33 @@ fn aiur_fn_617(
     let __v_14: G = __loaded[10];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_9, __v_7, __v_1, __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 __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_9, __v_7, __v_1, __v_2]; 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_15: G = __r_arr[0];
-        let __ret: [G; OUT_617] = [__v_15];
-        record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_620] = [__v_15];
+        record.function_queries[620].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_617] = [__v_17];
-        record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_620] = [__v_17];
+        record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_618: usize = 4;
-const IN_618: usize = 4;
-const OUT_618: usize = 1;
-fn aiur_fn_618(
-  inp: [G; IN_618],
+const INPUT_SIZE_621: usize = 4;
+const IN_621: usize = 4;
+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_618], ExecError> {
+) -> Result<[G; OUT_621], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52923,12 +52366,12 @@ fn aiur_fn_618(
         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_618] = [__v_9];
-        record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_621] = [__v_9];
+        record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __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];
@@ -52944,24 +52387,24 @@ fn aiur_fn_618(
         let __v_18: G = __loaded[10];
         match __v_8.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_10, __v_1]; 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 __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_10, __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_19: G = __r_arr[0];
             let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_19, __v_2, __v_3, __v_20]; 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 __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_19, __v_2, __v_3, __v_20]; 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_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_6, __v_1, __v_2, __v_3]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_618] = [__v_23];
-            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_621] = [__v_23];
+            record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_6, __v_1, __v_2, __v_3]; 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_19: G = __r_arr[0];
-            let __ret: [G; OUT_618] = [__v_19];
-            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_621] = [__v_19];
+            record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52973,15 +52416,15 @@ fn aiur_fn_618(
   })
 }
 
-const INPUT_SIZE_619: usize = 4;
-const IN_619: usize = 4;
-const OUT_619: usize = 1;
-fn aiur_fn_619(
-  inp: [G; IN_619],
+const INPUT_SIZE_622: usize = 4;
+const IN_622: usize = 4;
+const OUT_622: usize = 1;
+fn aiur_fn_622(
+  inp: [G; IN_622],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_619], ExecError> {
+) -> Result<[G; OUT_622], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52994,48 +52437,48 @@ fn aiur_fn_619(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } else { aiur_fn_620(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_5, __v_1, __v_2, __v_3]; 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_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_3 + __v_9);
-        let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_6, __v_1, __v_2, __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 __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_6, __v_1, __v_2, __v_10]; 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_619] = [__v_12];
-        record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_622] = [__v_12];
+        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = G::from_u64(1);
         let __v_10: G = { let __values: [G; 5] = [__v_8, __v_9, __v_9, __v_9, __v_9]; 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_619] = [__v_10];
-        record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_622] = [__v_10];
+        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_620: usize = 4;
-const IN_620: usize = 4;
-const OUT_620: usize = 1;
-fn aiur_fn_620(
-  inp: [G; IN_620],
+const INPUT_SIZE_623: usize = 4;
+const IN_623: usize = 4;
+const OUT_623: usize = 1;
+fn aiur_fn_623(
+  inp: [G; IN_623],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_620], ExecError> {
+) -> Result<[G; OUT_623], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0]; 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 __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0]; 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__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 __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 };
@@ -53045,19 +52488,19 @@ fn aiur_fn_620(
     let __v_11: G = __loaded[3];
     match __v_8.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_1, __v_9]; 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 __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_1, __v_9]; 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_12: G = __r_arr[0];
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_13: G = G::from_u64(1);
             let __v_14: G = G::from_u64(1);
             let __v_15: G = { let __values: [G; 5] = [__v_13, __v_14, __v_14, __v_14, __v_14]; 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_620] = [__v_15];
-            record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_623] = [__v_15];
+            record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_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];
@@ -53073,7 +52516,7 @@ fn aiur_fn_620(
             let __v_24: G = __loaded[10];
             match __v_14.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_7]; 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_25: G = __r_arr[0];
                 let __v_26: G = { let __a_val = __v_25.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_26.as_canonical_u64() {
@@ -53081,49 +52524,49 @@ fn aiur_fn_620(
                     let __v_27: G = G::from_u64(1);
                     let __v_28: G = G::from_u64(1);
                     let __v_29: G = { let __values: [G; 5] = [__v_27, __v_28, __v_28, __v_28, __v_28]; 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_620] = [__v_29];
-                    record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_623] = [__v_29];
+                    record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[784].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_784] = unsafe { *(result.output.as_ptr() as *const [G; OUT_784]) }; __ret } else { aiur_fn_784(__args, record, io_buffer, __cu)? } };
                     let __v_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_27, __v_1]; 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 __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_27, __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_28: G = __r_arr[0];
                     match __v_28.as_canonical_u64() {
                       0u64 => {
                         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 __ret: [G; OUT_620] = [__v_31];
-                        record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_623] = [__v_31];
+                        record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       1u64 => {
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_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_29: G = __r_arr[0];
                         let __v_30: G = (__v_3 + __v_29);
-                        let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_27, __v_30]; 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 __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_27, __v_30]; 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_31: G = __r_arr[0];
                         match __v_31.as_canonical_u64() {
                           0u64 => {
                             let __v_32: G = G::from_u64(1);
                             let __v_33: G = G::from_u64(1);
                             let __v_34: G = { let __values: [G; 5] = [__v_32, __v_33, __v_33, __v_33, __v_33]; 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_620] = [__v_34];
-                            record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_623] = [__v_34];
+                            record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           1u64 => {
-                            let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_27, __v_30]; 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 __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_27, __v_30]; 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_32: G = __r_arr[0];
                             let __v_33: G = G::from_u64(0);
                             let __v_34: G = G::from_u64(1);
                             let __v_35: G = G::from_u64(1);
                             let __v_36: G = { let __values: [G; 5] = [__v_34, __v_35, __v_35, __v_35, __v_35]; 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_37: G = { let __values: [G; 5] = [__v_33, __v_9, __v_32, __v_10, __v_36]; 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_620] = [__v_37];
-                            record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_623] = [__v_37];
+                            record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -53145,8 +52588,8 @@ fn aiur_fn_620(
                 let __v_25: G = G::from_u64(1);
                 let __v_26: G = G::from_u64(1);
                 let __v_27: G = { let __values: [G; 5] = [__v_25, __v_26, __v_26, __v_26, __v_26]; 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_620] = [__v_27];
-                record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_623] = [__v_27];
+                record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -53160,23 +52603,23 @@ fn aiur_fn_620(
         let __v_12: G = G::from_u64(1);
         let __v_13: G = G::from_u64(1);
         let __v_14: G = { let __values: [G; 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_620] = [__v_14];
-        record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_623] = [__v_14];
+        record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_621: usize = 2;
-const IN_621: usize = 2;
-const OUT_621: usize = 1;
-fn aiur_fn_621(
-  inp: [G; IN_621],
+const INPUT_SIZE_624: usize = 2;
+const IN_624: usize = 2;
+const OUT_624: usize = 1;
+fn aiur_fn_624(
+  inp: [G; IN_624],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_621], ExecError> {
+) -> Result<[G; OUT_624], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53187,26 +52630,26 @@ fn aiur_fn_621(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_621] = [__v_5];
-        record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_624] = [__v_5];
+        record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_3, __v_5, __v_1]; 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 __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_3, __v_5, __v_1]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_621] = [__v_7];
-            record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_624] = [__v_7];
+            record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_621] = [__v_7];
-            record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_624] = [__v_7];
+            record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -53221,15 +52664,15 @@ fn aiur_fn_621(
   })
 }
 
-const INPUT_SIZE_622: usize = 2;
-const IN_622: usize = 2;
-const OUT_622: usize = 1;
-fn aiur_fn_622(
-  inp: [G; IN_622],
+const INPUT_SIZE_625: usize = 2;
+const IN_625: usize = 2;
+const OUT_625: usize = 1;
+fn aiur_fn_625(
+  inp: [G; IN_625],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_622], ExecError> {
+) -> Result<[G; OUT_625], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53242,20 +52685,20 @@ fn aiur_fn_622(
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_622] = [__v_7];
-        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_625] = [__v_7];
+        record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_3, __v_1, __v_6]; 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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3, __v_1, __v_6]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_4, __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_8: G = __r_arr[0];
         let __v_9: G = { let __values: [G; 3] = [__v_5, __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_622] = [__v_9];
-        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_625] = [__v_9];
+        record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53265,15 +52708,15 @@ fn aiur_fn_622(
   })
 }
 
-const INPUT_SIZE_623: usize = 6;
-const IN_623: usize = 6;
-const OUT_623: usize = 1;
-fn aiur_fn_623(
-  inp: [G; IN_623],
+const INPUT_SIZE_626: usize = 6;
+const IN_626: usize = 6;
+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_623], ExecError> {
+) -> Result<[G; OUT_626], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53283,15 +52726,15 @@ fn aiur_fn_623(
     let __v_5: G = inp[5];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_623] = [__v_0];
-        record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_626] = [__v_0];
+        record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_8, __v_4, __v_5]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_8, __v_4, __v_5]; 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_9: G = __r_arr[0];
         let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
@@ -53300,19 +52743,19 @@ fn aiur_fn_623(
         let __v_13: G = __loaded[3];
         match __v_10.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __v_15: G = G::from_u64(0);
-            let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_12, __v_14, __v_15]; 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 __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_12, __v_14, __v_15]; 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_16: G = __r_arr[0];
             let __v_17: G = G::from_u64(1);
             let __v_18: G = (__v_1 - __v_17);
             let __v_19: G = G::from_u64(1);
             let __v_20: G = (__v_3 + __v_19);
-            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_16, __v_18, __v_2, __v_20, __v_4, __v_5]; 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 __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_16, __v_18, __v_2, __v_20, __v_4, __v_5]; 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_21: G = __r_arr[0];
-            let __ret: [G; OUT_623] = [__v_21];
-            record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_626] = [__v_21];
+            record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -53324,15 +52767,15 @@ fn aiur_fn_623(
   })
 }
 
-const INPUT_SIZE_624: usize = 6;
-const IN_624: usize = 6;
-const OUT_624: usize = 1;
-fn aiur_fn_624(
-  inp: [G; IN_624],
+const INPUT_SIZE_627: usize = 6;
+const IN_627: usize = 6;
+const OUT_627: usize = 1;
+fn aiur_fn_627(
+  inp: [G; IN_627],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_624], ExecError> {
+) -> Result<[G; OUT_627], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53340,26 +52783,26 @@ fn aiur_fn_624(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0, __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_3]; 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_6: G = __r_arr[0];
     let __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_6, __v_1, __v_2, __v_7, __v_4, __v_5]; 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 __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_6, __v_1, __v_2, __v_7, __v_4, __v_5]; 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_8: G = __r_arr[0];
-    let __ret: [G; OUT_624] = [__v_8];
-    record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_627] = [__v_8];
+    record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_625: usize = 21;
-const IN_625: usize = 21;
-const OUT_625: usize = 1;
-fn aiur_fn_625(
-  inp: [G; IN_625],
+const INPUT_SIZE_628: usize = 21;
+const IN_628: usize = 21;
+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_625], ExecError> {
+) -> Result<[G; OUT_628], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53391,12 +52834,12 @@ fn aiur_fn_625(
         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_625] = [__v_26];
-        record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_628] = [__v_26];
+        record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_18, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_18, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
         let __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];
@@ -53412,16 +52855,16 @@ fn aiur_fn_625(
         let __v_35: G = __loaded[10];
         match __v_25.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_28, __v_22, __v_27, __v_20, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_28, __v_22, __v_27, __v_20, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_36: G = __r_arr[0];
             let __v_37: G = G::from_u64(0);
             let __v_38: G = G::from_u64(1);
             let __v_39: G = (__v_20 + __v_38);
-            let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_1, __v_23, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_39]; 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 __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_0, __v_1, __v_23, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_39]; 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_40: G = __r_arr[0];
             let __v_41: G = { let __values: [G; 5] = [__v_37, __v_22, __v_31, __v_36, __v_40]; 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_625] = [__v_41];
-            record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_628] = [__v_41];
+            record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -53436,15 +52879,15 @@ fn aiur_fn_625(
   })
 }
 
-const INPUT_SIZE_626: usize = 11;
-const IN_626: usize = 11;
-const OUT_626: usize = 1;
-fn aiur_fn_626(
-  inp: [G; IN_626],
+const INPUT_SIZE_629: usize = 11;
+const IN_629: usize = 11;
+const OUT_629: usize = 1;
+fn aiur_fn_629(
+  inp: [G; IN_629],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_626], ExecError> {
+) -> Result<[G; OUT_629], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53466,36 +52909,36 @@ fn aiur_fn_626(
         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_626] = [__v_16];
-        record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_629] = [__v_16];
+        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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_767] = { let __args: [G; IN_767] = [__v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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_395] = { let __args: [G; IN_395] = [__v_18, __v_20, __v_21]; 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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_18, __v_20, __v_21]; 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_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_22, __v_7, __v_8, __v_9]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_22, __v_7, __v_8, __v_9]; 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_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_23]; 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 __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_23]; 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_24: G = __r_arr[0];
         let __v_25: G = __r_arr[1];
-        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_26, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_26, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_25, __v_27, __v_8, __v_9]; 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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_25, __v_27, __v_8, __v_9]; 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_24]; 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_29: G = __r_arr[0];
         let __v_30: G = (__v_17 + __v_29);
         let __v_31: G = G::from_u64(1);
@@ -53506,35 +52949,35 @@ fn aiur_fn_626(
         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_198] = { let __args: [G; IN_198] = [__v_28]; 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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __v_39: G = __r_arr[0];
         let __v_40: G = __r_arr[1];
-        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_40, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_40, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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_404] = { let __args: [G; IN_404] = [__v_44, __v_41]; 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 __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_44, __v_41]; 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_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_530] = { let __args: [G; IN_530] = [__v_48, __v_29, __v_49]; 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 __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_48, __v_29, __v_49]; 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_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_531] = { let __args: [G; IN_531] = [__v_53, __v_24]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_53, __v_24]; 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_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_626] = { let __args: [G; IN_626] = [__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[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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__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[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 __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_626] = [__v_59];
-        record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_629] = [__v_59];
+        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53544,15 +52987,15 @@ fn aiur_fn_626(
   })
 }
 
-const INPUT_SIZE_627: usize = 7;
-const IN_627: usize = 7;
-const OUT_627: usize = 0;
-fn aiur_fn_627(
-  inp: [G; IN_627],
+const INPUT_SIZE_630: usize = 7;
+const IN_630: usize = 7;
+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_627], ExecError> {
+) -> Result<[G; OUT_630], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53594,19 +53037,19 @@ fn aiur_fn_627(
     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_126] = { let __args: [G; IN_126] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4, __v_39]; 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_40: G = __r_arr[0];
     match __v_40.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_627] = [];
-        record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_630] = [];
+        record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_41: G = G::from_u64(0);
-        let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__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[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 __ret: [G; OUT_627] = [];
-        record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__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[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 __ret: [G; OUT_630] = [];
+        record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53616,15 +53059,15 @@ fn aiur_fn_627(
   })
 }
 
-const INPUT_SIZE_628: usize = 9;
-const IN_628: usize = 9;
-const OUT_628: usize = 0;
-fn aiur_fn_628(
-  inp: [G; IN_628],
+const INPUT_SIZE_631: usize = 9;
+const IN_631: usize = 9;
+const OUT_631: usize = 0;
+fn aiur_fn_631(
+  inp: [G; IN_631],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_628], ExecError> {
+) -> Result<[G; OUT_631], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53641,8 +53084,8 @@ fn aiur_fn_628(
     let __v_11: G = __loaded[2];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_628] = [];
-        record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_631] = [];
+        record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -53660,7 +53103,7 @@ fn aiur_fn_628(
         let __v_22: G = __loaded[10];
         match __v_12.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
             let __v_24: G = (__v_8 - __v_0);
             let __v_25: G = G::from_bool((__v_24 == G::ZERO));
@@ -53669,23 +53112,23 @@ fn aiur_fn_628(
             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_629] = { let __args: [G; IN_629] = [__v_1, __v_14, __v_2, __v_6, __v_7]; 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_632] = { let __args: [G; IN_632] = [__v_1, __v_14, __v_2, __v_6, __v_7]; 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_29: G = (__v_2 + __v_3);
                 let __v_30: G = G::from_u64(1);
                 let __v_31: G = G::from_u64(1);
                 let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_1, __v_29, __v_32, __v_6, __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 __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_1, __v_29, __v_32, __v_6, __v_7]; 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_33: G = __r_arr[0];
                 let __v_34: G = (__v_15 + __v_16);
                 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_494] = { let __args: [G; IN_494] = [__v_14, __v_34, __v_37, __v_6, __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 __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_14, __v_34, __v_37, __v_6, __v_7]; 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_38: G = __r_arr[0];
-                let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_33, __v_38]; 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)? } };
+                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_228] = { let __args: [G; IN_228] = [__v_33, __v_38]; 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_39: G = __r_arr[0];
                 let __v_40: G = G::from_u64(1);
                 if (__v_39 != __v_40) {
@@ -53693,17 +53136,17 @@ fn aiur_fn_628(
                 }
                 let __v_41: G = G::from_u64(1);
                 let __v_42: G = (__v_8 + __v_41);
-                let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_42]; 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 __ret: [G; OUT_628] = [];
-                record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_42]; 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 __ret: [G; OUT_631] = [];
+                record.function_queries[631].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_628] = { let __args: [G; IN_628] = [__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[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 __ret: [G; OUT_628] = [];
-                record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__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[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 __ret: [G; OUT_631] = [];
+                record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -53714,9 +53157,9 @@ fn aiur_fn_628(
           _ => {
             let __v_23: G = G::from_u64(1);
             let __v_24: G = (__v_8 + __v_23);
-            let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__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[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 __ret: [G; OUT_628] = [];
-            record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__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[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 __ret: [G; OUT_631] = [];
+            record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -53728,15 +53171,15 @@ fn aiur_fn_628(
   })
 }
 
-const INPUT_SIZE_629: usize = 5;
-const IN_629: usize = 5;
-const OUT_629: usize = 0;
-fn aiur_fn_629(
-  inp: [G; IN_629],
+const INPUT_SIZE_632: usize = 5;
+const IN_632: usize = 5;
+const OUT_632: usize = 0;
+fn aiur_fn_632(
+  inp: [G; IN_632],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_629], ExecError> {
+) -> Result<[G; OUT_632], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53746,22 +53189,22 @@ fn aiur_fn_629(
     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_630] = { let __args: [G; IN_630] = [__v_0, __v_1, __v_2, __v_7, __v_3, __v_4]; 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));
+    let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_0, __v_1, __v_2, __v_7, __v_3, __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 __ret: [G; OUT_632] = [];
+    record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_630: usize = 6;
-const IN_630: usize = 6;
-const OUT_630: usize = 0;
-fn aiur_fn_630(
-  inp: [G; IN_630],
+const INPUT_SIZE_633: usize = 6;
+const IN_633: usize = 6;
+const OUT_633: usize = 0;
+fn aiur_fn_633(
+  inp: [G; IN_633],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_630], ExecError> {
+) -> Result<[G; OUT_633], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53771,8 +53214,8 @@ fn aiur_fn_630(
     let __v_5: G = inp[5];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_630] = [];
-        record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_633] = [];
+        record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53790,19 +53233,19 @@ fn aiur_fn_630(
             let __v_13: G = __loaded[3];
             match __v_10.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_7, __v_11, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_7, __v_11, __v_3, __v_4, __v_5]; 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_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_15: G = G::from_u64(0);
+                let __v_16: G = { let __values: [G; 3] = [__v_15, __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_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_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_630] = { let __args: [G; IN_630] = [__v_8, __v_12, __v_19, __v_17, __v_4, __v_5]; 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_630] = [];
-                record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_8, __v_12, __v_19, __v_16, __v_4, __v_5]; 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 __ret: [G; OUT_633] = [];
+                record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -53819,15 +53262,15 @@ fn aiur_fn_630(
   })
 }
 
-const INPUT_SIZE_631: usize = 2;
-const IN_631: usize = 2;
-const OUT_631: usize = 1;
-fn aiur_fn_631(
-  inp: [G; IN_631],
+const INPUT_SIZE_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_631], ExecError> {
+) -> Result<[G; OUT_634], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53835,8 +53278,8 @@ fn aiur_fn_631(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_631] = [__v_3];
-        record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_634] = [__v_3];
+        record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53844,14 +53287,14 @@ fn aiur_fn_631(
         match __v_3.as_canonical_u64() {
           1u64 => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_631] = [__v_4];
-            record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_634] = [__v_4];
+            record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_4: G = G::from_u64(2);
-            let __ret: [G; OUT_631] = [__v_4];
-            record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_634] = [__v_4];
+            record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -53863,132 +53306,132 @@ fn aiur_fn_631(
   })
 }
 
-const INPUT_SIZE_632: usize = 2;
-const IN_632: usize = 2;
-const OUT_632: usize = 1;
-fn aiur_fn_632(
-  inp: [G; IN_632],
+const INPUT_SIZE_635: usize = 2;
+const IN_635: usize = 2;
+const OUT_635: usize = 1;
+fn aiur_fn_635(
+  inp: [G; IN_635],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_632], ExecError> {
+) -> Result<[G; OUT_635], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_632] = [__v_1];
-        record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_635] = [__v_1];
+        record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_632] = [__v_0];
-        record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_635] = [__v_0];
+        record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_633: usize = 0;
-const IN_633: usize = 0;
-const OUT_633: usize = 2;
-fn aiur_fn_633(
-  inp: [G; IN_633],
+const INPUT_SIZE_636: usize = 0;
+const IN_636: usize = 0;
+const OUT_636: usize = 2;
+fn aiur_fn_636(
+  inp: [G; IN_636],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_633], ExecError> {
+) -> Result<[G; OUT_636], 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_633] = [__v_0, __v_1];
-    record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_636] = [__v_0, __v_1];
+    record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_634: usize = 0;
-const IN_634: usize = 0;
-const OUT_634: usize = 2;
-fn aiur_fn_634(
-  inp: [G; IN_634],
+const INPUT_SIZE_637: usize = 0;
+const IN_637: usize = 0;
+const OUT_637: usize = 2;
+fn aiur_fn_637(
+  inp: [G; IN_637],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_634], ExecError> {
+) -> Result<[G; OUT_637], 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_634] = [__v_0, __v_1];
-    record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_637] = [__v_0, __v_1];
+    record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_635: usize = 0;
-const IN_635: usize = 0;
-const OUT_635: usize = 2;
-fn aiur_fn_635(
-  inp: [G; IN_635],
+const INPUT_SIZE_638: usize = 0;
+const IN_638: usize = 0;
+const OUT_638: usize = 2;
+fn aiur_fn_638(
+  inp: [G; IN_638],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_635], ExecError> {
+) -> Result<[G; OUT_638], 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_635] = [__v_0, __v_1];
-    record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_638] = [__v_0, __v_1];
+    record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_636: usize = 0;
-const IN_636: usize = 0;
-const OUT_636: usize = 2;
-fn aiur_fn_636(
-  inp: [G; IN_636],
+const INPUT_SIZE_639: usize = 0;
+const IN_639: usize = 0;
+const OUT_639: usize = 2;
+fn aiur_fn_639(
+  inp: [G; IN_639],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_636], ExecError> {
+) -> Result<[G; OUT_639], 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_636] = [__v_0, __v_1];
-    record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_639] = [__v_0, __v_1];
+    record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_637: usize = 0;
-const IN_637: usize = 0;
-const OUT_637: usize = 2;
-fn aiur_fn_637(
-  inp: [G; IN_637],
+const INPUT_SIZE_640: usize = 0;
+const IN_640: usize = 0;
+const OUT_640: usize = 2;
+fn aiur_fn_640(
+  inp: [G; IN_640],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_637], ExecError> {
+) -> Result<[G; OUT_640], 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_637] = [__v_0, __v_1];
-    record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_640] = [__v_0, __v_1];
+    record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_638: usize = 4;
-const IN_638: usize = 4;
-const OUT_638: usize = 2;
-fn aiur_fn_638(
-  inp: [G; IN_638],
+const INPUT_SIZE_641: usize = 4;
+const IN_641: usize = 4;
+const OUT_641: usize = 2;
+fn aiur_fn_641(
+  inp: [G; IN_641],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_638], ExecError> {
+) -> Result<[G; OUT_641], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53997,46 +53440,46 @@ fn aiur_fn_638(
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __v_4: G = (__v_1 * __v_3);
-        let __ret: [G; OUT_638] = [__v_2, __v_4];
-        record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_641] = [__v_2, __v_4];
+        record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_638] = [__v_0, __v_1];
-        record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_641] = [__v_0, __v_1];
+        record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_639: usize = 1;
-const IN_639: usize = 1;
-const OUT_639: usize = 2;
-fn aiur_fn_639(
-  inp: [G; IN_639],
+const INPUT_SIZE_642: usize = 1;
+const IN_642: usize = 1;
+const OUT_642: usize = 2;
+fn aiur_fn_642(
+  inp: [G; IN_642],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_639], ExecError> {
+) -> Result<[G; OUT_642], 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_639] = [__v_0, __v_1];
-    record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_642] = [__v_0, __v_1];
+    record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_640: usize = 2;
-const IN_640: usize = 2;
-const OUT_640: usize = 1;
-fn aiur_fn_640(
-  inp: [G; IN_640],
+const INPUT_SIZE_643: usize = 2;
+const IN_643: usize = 2;
+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_640], ExecError> {
+) -> Result<[G; OUT_643], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54048,8 +53491,8 @@ fn aiur_fn_640(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_640] = [__v_6];
-        record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_643] = [__v_6];
+        record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -54058,15 +53501,15 @@ fn aiur_fn_640(
           0u64 => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_7 + __v_4);
-            let __ret: [G; OUT_640] = [__v_8];
-            record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_643] = [__v_8];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_0, __v_5]; 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 __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_640] = [__v_7];
-            record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_643] = [__v_7];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54078,15 +53521,15 @@ fn aiur_fn_640(
   })
 }
 
-const INPUT_SIZE_641: usize = 2;
-const IN_641: usize = 2;
-const OUT_641: usize = 1;
-fn aiur_fn_641(
-  inp: [G; IN_641],
+const INPUT_SIZE_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_641], ExecError> {
+) -> Result<[G; OUT_644], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54156,51 +53599,51 @@ fn aiur_fn_641(
     let __v_63: G = __loaded[29];
     let __v_64: G = __loaded[30];
     let __v_65: G = __loaded[31];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_66: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_67: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_72: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_73: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_72, __v_73]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_72, __v_73]; 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_74: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_71, __v_74]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_71, __v_74]; 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_75: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_70, __v_75]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_70, __v_75]; 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_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_69, __v_76]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_69, __v_76]; 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_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_68, __v_77]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_68, __v_77]; 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_78: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_67, __v_78]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_67, __v_78]; 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_79: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_66, __v_79]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_66, __v_79]; 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_80: G = __r_arr[0];
-    let __ret: [G; OUT_641] = [__v_80];
-    record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_644] = [__v_80];
+    record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_642: usize = 8;
-const IN_642: usize = 8;
-const OUT_642: usize = 1;
-fn aiur_fn_642(
-  inp: [G; IN_642],
+const INPUT_SIZE_645: usize = 8;
+const IN_645: usize = 8;
+const OUT_645: usize = 1;
+fn aiur_fn_645(
+  inp: [G; IN_645],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_642], ExecError> {
+) -> Result<[G; OUT_645], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54228,23 +53671,23 @@ fn aiur_fn_642(
     let __v_23: G = (__v_22 + __v_7);
     let __v_24: G = (__v_20 + __v_23);
     let __v_25: G = (__v_18 + __v_24);
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_16, __v_25]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_16, __v_25]; 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_26: G = __r_arr[0];
-    let __ret: [G; OUT_642] = [__v_26];
-    record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_645] = [__v_26];
+    record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_643: usize = 4;
-const IN_643: usize = 4;
-const OUT_643: usize = 2;
-fn aiur_fn_643(
-  inp: [G; IN_643],
+const INPUT_SIZE_646: usize = 4;
+const IN_646: usize = 4;
+const OUT_646: usize = 2;
+fn aiur_fn_646(
+  inp: [G; IN_646],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_643], ExecError> {
+) -> Result<[G; OUT_646], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54253,41 +53696,41 @@ fn aiur_fn_643(
     let __v_4: G = (__v_0 - __v_1);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = []; 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = []; 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_643] = [__v_5, __v_6];
-        record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_646] = [__v_5, __v_6];
+        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_0, __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 __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_2]; 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__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 __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_1, __v_2]; 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_6: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           0u64 => {
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
-                let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_7, __v_8]; 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 __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_7, __v_8]; 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_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_9]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_9]; 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_10: G = __r_arr[0];
                 let __v_11: G = __r_arr[1];
-                let __ret: [G; OUT_643] = [__v_10, __v_11];
-                record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_646] = [__v_10, __v_11];
+                record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_7: G = __r_arr[0];
                 let __v_8: G = __r_arr[1];
-                let __ret: [G; OUT_643] = [__v_7, __v_8];
-                record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_646] = [__v_7, __v_8];
+                record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -54295,19 +53738,19 @@ fn aiur_fn_643(
           _ => {
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = []; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = []; 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 __v_8: G = __r_arr[1];
-                let __ret: [G; OUT_643] = [__v_7, __v_8];
-                record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_646] = [__v_7, __v_8];
+                record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_6]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_5, __v_6]; 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_7: G = __r_arr[0];
                 let __v_8: G = G::from_u64(0);
-                let __ret: [G; OUT_643] = [__v_7, __v_8];
-                record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_646] = [__v_7, __v_8];
+                record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -54318,15 +53761,15 @@ fn aiur_fn_643(
   })
 }
 
-const INPUT_SIZE_644: usize = 2;
-const IN_644: usize = 2;
-const OUT_644: usize = 1;
-fn aiur_fn_644(
-  inp: [G; IN_644],
+const INPUT_SIZE_647: usize = 2;
+const IN_647: usize = 2;
+const OUT_647: usize = 1;
+fn aiur_fn_647(
+  inp: [G; IN_647],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_644], ExecError> {
+) -> Result<[G; OUT_647], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54343,14 +53786,14 @@ fn aiur_fn_644(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54363,21 +53806,21 @@ fn aiur_fn_644(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_6]; 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 __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54390,31 +53833,31 @@ fn aiur_fn_644(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_6]; 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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_644] = [__v_10];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_10];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54427,37 +53870,37 @@ fn aiur_fn_644(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].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_6]; 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 __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_6]; 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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_644] = [__v_10];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_10];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -54472,16 +53915,16 @@ fn aiur_fn_644(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_3, __v_6]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_647] = [__v_8];
+            record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54493,15 +53936,15 @@ fn aiur_fn_644(
   })
 }
 
-const INPUT_SIZE_645: usize = 2;
-const IN_645: usize = 2;
-const OUT_645: usize = 1;
-fn aiur_fn_645(
-  inp: [G; IN_645],
+const INPUT_SIZE_648: usize = 2;
+const IN_648: usize = 2;
+const OUT_648: usize = 1;
+fn aiur_fn_648(
+  inp: [G; IN_648],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_645], ExecError> {
+) -> Result<[G; OUT_648], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54518,14 +53961,14 @@ fn aiur_fn_645(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_645] = [__v_8];
-            record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_648] = [__v_8];
+            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_645] = [__v_8];
-            record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_648] = [__v_8];
+            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54538,19 +53981,19 @@ fn aiur_fn_645(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_645] = [__v_8];
-            record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_648] = [__v_8];
+            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_6]; 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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_7]; 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_648] = { let __args: [G; IN_648] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_645] = [__v_10];
-            record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_648] = [__v_10];
+            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -54565,38 +54008,38 @@ fn aiur_fn_645(
   })
 }
 
-const INPUT_SIZE_646: usize = 2;
-const IN_646: usize = 2;
-const OUT_646: usize = 2;
-fn aiur_fn_646(
-  inp: [G; IN_646],
+const INPUT_SIZE_649: usize = 2;
+const IN_649: usize = 2;
+const OUT_649: usize = 2;
+fn aiur_fn_649(
+  inp: [G; IN_649],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_646], ExecError> {
+) -> Result<[G; OUT_649], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_1]; 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_648] = { let __args: [G; IN_648] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_2]; 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_646] = [__v_3, __v_4];
-    record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_649] = [__v_3, __v_4];
+    record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_647: usize = 2;
-const IN_647: usize = 2;
-const OUT_647: usize = 1;
-fn aiur_fn_647(
-  inp: [G; IN_647],
+const INPUT_SIZE_650: usize = 2;
+const IN_650: usize = 2;
+const OUT_650: usize = 1;
+fn aiur_fn_650(
+  inp: [G; IN_650],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_647], ExecError> {
+) -> Result<[G; OUT_650], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54604,8 +54047,8 @@ fn aiur_fn_647(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_647] = [__v_3];
-        record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_650] = [__v_3];
+        record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -54619,25 +54062,25 @@ fn aiur_fn_647(
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
-        let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__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[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_651] = { let __args: [G; IN_651] = [__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[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_11: G = __r_arr[0];
-        let __ret: [G; OUT_647] = [__v_11];
-        record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_650] = [__v_11];
+        record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_648: usize = 8;
-const IN_648: usize = 8;
-const OUT_648: usize = 1;
-fn aiur_fn_648(
-  inp: [G; IN_648],
+const INPUT_SIZE_651: usize = 8;
+const IN_651: usize = 8;
+const OUT_651: usize = 1;
+fn aiur_fn_651(
+  inp: [G; IN_651],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_648], ExecError> {
+) -> Result<[G; OUT_651], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54651,16 +54094,16 @@ fn aiur_fn_648(
       0u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_5]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54669,21 +54112,21 @@ fn aiur_fn_648(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_1, __v_5]; 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 __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54692,31 +54135,31 @@ fn aiur_fn_648(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_2, __v_6]; 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_648] = { let __args: [G; IN_648] = [__v_2, __v_6]; 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 = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_5]; 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_648] = [__v_10];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_10];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54725,37 +54168,37 @@ fn aiur_fn_648(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_1, __v_5]; 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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_6]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_6]; 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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_648] = [__v_10];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_10];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54764,43 +54207,43 @@ fn aiur_fn_648(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_1, __v_5]; 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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_6]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_6]; 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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_648] = [__v_10];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_10];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54809,49 +54252,49 @@ fn aiur_fn_648(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_1, __v_5]; 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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_6]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_6]; 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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_648] = [__v_10];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_10];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54860,59 +54303,59 @@ fn aiur_fn_648(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_1, __v_5]; 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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_6]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_6]; 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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_7]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_3, __v_7]; 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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_9, __v_10]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_9, __v_10]; 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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_8, __v_11]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_8, __v_11]; 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_648] = [__v_12];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_12];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54921,21 +54364,21 @@ fn aiur_fn_648(
         match __v_4.as_canonical_u64() {
           8u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           7u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_1, __v_2, __v_5, __v_6]; 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 __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_2, __v_5, __v_6]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54943,24 +54386,24 @@ fn aiur_fn_648(
       8u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_5]; 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_2, __v_6]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_2, __v_6]; 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_7]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_3, __v_7]; 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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_9, __v_10]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_9, __v_10]; 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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_8, __v_11]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_8, __v_11]; 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_648] = [__v_12];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_12];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_648] = [__v_8];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_651] = [__v_8];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54972,15 +54415,15 @@ fn aiur_fn_648(
   })
 }
 
-const INPUT_SIZE_649: usize = 4;
-const IN_649: usize = 4;
-const OUT_649: usize = 2;
-fn aiur_fn_649(
-  inp: [G; IN_649],
+const INPUT_SIZE_652: usize = 4;
+const IN_652: usize = 4;
+const OUT_652: usize = 2;
+fn aiur_fn_652(
+  inp: [G; IN_652],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_649], ExecError> {
+) -> Result<[G; OUT_652], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54989,11 +54432,11 @@ fn aiur_fn_649(
     let __v_4: G = (__v_0 - __v_1);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = []; 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = []; 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_649] = [__v_5, __v_6];
-        record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_652] = [__v_5, __v_6];
+        record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -55007,26 +54450,26 @@ fn aiur_fn_649(
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
         let __v_12: G = __loaded[3];
-        let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_2, __v_3]; 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 __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_2, __v_3]; 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 __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_649] = [__v_13, __v_14];
-        record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_652] = [__v_13, __v_14];
+        record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_650: usize = 10;
-const IN_650: usize = 10;
-const OUT_650: usize = 2;
-fn aiur_fn_650(
-  inp: [G; IN_650],
+const INPUT_SIZE_653: usize = 10;
+const IN_653: usize = 10;
+const OUT_653: usize = 2;
+fn aiur_fn_653(
+  inp: [G; IN_653],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_650], ExecError> {
+) -> Result<[G; OUT_653], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55042,21 +54485,21 @@ fn aiur_fn_650(
       0u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_5]; 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_10]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_10]; 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_11, __v_12];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_11, __v_12];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = []; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55064,29 +54507,29 @@ fn aiur_fn_650(
       1u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_1, __v_5]; 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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_10]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_10]; 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_11, __v_12];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_11, __v_12];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = []; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55094,41 +54537,41 @@ fn aiur_fn_650(
       2u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_2, __v_6]; 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_649] = { let __args: [G; IN_649] = [__v_2, __v_6]; 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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_1, __v_5, __v_8, __v_9]; 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 __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_1, __v_5, __v_8, __v_9]; 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 __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_10, __v_11, __v_12, __v_13]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_14, __v_15];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_14, __v_15];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = []; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55136,49 +54579,49 @@ fn aiur_fn_650(
       3u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_1, __v_5, __v_8, __v_9]; 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_652] = { let __args: [G; IN_652] = [__v_1, __v_5, __v_8, __v_9]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_6, __v_8, __v_9]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_6, __v_8, __v_9]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_10, __v_11, __v_12, __v_13]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_14, __v_15];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_14, __v_15];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = []; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55186,57 +54629,57 @@ fn aiur_fn_650(
       4u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_1, __v_5, __v_8, __v_9]; 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_652] = { let __args: [G; IN_652] = [__v_1, __v_5, __v_8, __v_9]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_6, __v_8, __v_9]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_6, __v_8, __v_9]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_10, __v_11, __v_12, __v_13]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_14, __v_15];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_14, __v_15];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = []; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55244,65 +54687,65 @@ fn aiur_fn_650(
       5u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_1, __v_5, __v_8, __v_9]; 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_652] = { let __args: [G; IN_652] = [__v_1, __v_5, __v_8, __v_9]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_6, __v_8, __v_9]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_6, __v_8, __v_9]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_10, __v_11, __v_12, __v_13]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_14, __v_15];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_14, __v_15];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = []; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55310,79 +54753,79 @@ fn aiur_fn_650(
       6u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_1, __v_5, __v_8, __v_9]; 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_652] = { let __args: [G; IN_652] = [__v_1, __v_5, __v_8, __v_9]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_6, __v_8, __v_9]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_6, __v_8, __v_9]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_3, __v_7, __v_8, __v_9]; 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_652] = { let __args: [G; IN_652] = [__v_3, __v_7, __v_8, __v_9]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_12, __v_13, __v_14, __v_15]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_12, __v_13, __v_14, __v_15]; 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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_10, __v_11, __v_16, __v_17]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_10, __v_11, __v_16, __v_17]; 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_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_18, __v_19];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_18, __v_19];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = []; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55390,29 +54833,29 @@ fn aiur_fn_650(
       7u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = []; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           7u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_1, __v_2, __v_5, __v_6]; 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 __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_2, __v_5, __v_6]; 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 __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_10]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_10]; 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_11, __v_12];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_11, __v_12];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55420,33 +54863,33 @@ fn aiur_fn_650(
       8u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_1, __v_5, __v_8, __v_9]; 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 __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_1, __v_5, __v_8, __v_9]; 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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_2, __v_6]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_2, __v_6]; 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_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_12]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_12]; 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_3, __v_7, __v_8, __v_9]; 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_652] = { let __args: [G; IN_652] = [__v_3, __v_7, __v_8, __v_9]; 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_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_13, __v_14, __v_15, __v_16]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_13, __v_14, __v_15, __v_16]; 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_17: G = __r_arr[0];
             let __v_18: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_10, __v_11, __v_17, __v_18]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_10, __v_11, __v_17, __v_18]; 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_19: G = __r_arr[0];
             let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_19, __v_20];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_19, __v_20];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_650] = [__v_10, __v_11];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_10, __v_11];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55458,15 +54901,15 @@ fn aiur_fn_650(
   })
 }
 
-const INPUT_SIZE_651: usize = 4;
-const IN_651: usize = 4;
-const OUT_651: usize = 1;
-fn aiur_fn_651(
-  inp: [G; IN_651],
+const INPUT_SIZE_654: usize = 4;
+const IN_654: usize = 4;
+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_651], ExecError> {
+) -> Result<[G; OUT_654], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55476,16 +54919,16 @@ fn aiur_fn_651(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_1, __v_3]; 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 __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_651] = [__v_4];
-            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_654] = [__v_4];
+            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_651] = [__v_4];
-            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_654] = [__v_4];
+            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55497,15 +54940,15 @@ fn aiur_fn_651(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_4: G = G::from_u64(2);
-            let __ret: [G; OUT_651] = [__v_4];
-            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_654] = [__v_4];
+            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_1, __v_3]; 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_4: G = __r_arr[0];
-            let __ret: [G; OUT_651] = [__v_4];
-            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_654] = [__v_4];
+            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55520,54 +54963,54 @@ fn aiur_fn_651(
   })
 }
 
-const INPUT_SIZE_652: usize = 2;
-const IN_652: usize = 2;
-const OUT_652: usize = 1;
-fn aiur_fn_652(
-  inp: [G; IN_652],
+const INPUT_SIZE_655: usize = 2;
+const IN_655: usize = 2;
+const OUT_655: usize = 1;
+fn aiur_fn_655(
+  inp: [G; IN_655],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_652], ExecError> {
+) -> Result<[G; OUT_655], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !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 __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_5]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_5]; 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_6: G = __r_arr[0];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_2, __v_3]; 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 __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_652] = [__v_7];
-        record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_655] = [__v_7];
+        record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_652] = [__v_6];
-        record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_655] = [__v_6];
+        record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_653: usize = 2;
-const IN_653: usize = 2;
-const OUT_653: usize = 1;
-fn aiur_fn_653(
-  inp: [G; IN_653],
+const INPUT_SIZE_656: usize = 2;
+const IN_656: usize = 2;
+const OUT_656: usize = 1;
+fn aiur_fn_656(
+  inp: [G; IN_656],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_653], ExecError> {
+) -> Result<[G; OUT_656], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55585,8 +55028,8 @@ fn aiur_fn_653(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_653] = [__v_12];
-        record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_656] = [__v_12];
+        record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -55603,14 +55046,14 @@ fn aiur_fn_653(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_11, __v_21]; 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 __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_11, __v_21]; 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 __v_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__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[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 __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__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[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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_22, __v_23]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_22, __v_23]; 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_24: G = __r_arr[0];
-            let __ret: [G; OUT_653] = [__v_24];
-            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_656] = [__v_24];
+            record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55625,15 +55068,15 @@ fn aiur_fn_653(
   })
 }
 
-const INPUT_SIZE_654: usize = 16;
-const IN_654: usize = 16;
-const OUT_654: usize = 1;
-fn aiur_fn_654(
-  inp: [G; IN_654],
+const INPUT_SIZE_657: usize = 16;
+const IN_657: usize = 16;
+const OUT_657: usize = 1;
+fn aiur_fn_657(
+  inp: [G; IN_657],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_654], ExecError> {
+) -> Result<[G; OUT_657], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55651,51 +55094,51 @@ fn aiur_fn_654(
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_7, __v_15]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_7, __v_15]; 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_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_14]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_6, __v_14]; 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_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_13]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_5, __v_13]; 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_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_12]; 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_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_11]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_3, __v_11]; 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_20: G = __r_arr[0];
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_2, __v_10]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_2, __v_10]; 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_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_9]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_9]; 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_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_0, __v_8]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_8]; 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_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_22, __v_23]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_22, __v_23]; 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_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_21, __v_24]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_21, __v_24]; 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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_20, __v_25]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_20, __v_25]; 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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_19, __v_26]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_19, __v_26]; 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_27: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_18, __v_27]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_18, __v_27]; 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_28: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_17, __v_28]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_17, __v_28]; 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_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_16, __v_29]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_16, __v_29]; 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_30: G = __r_arr[0];
-    let __ret: [G; OUT_654] = [__v_30];
-    record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_657] = [__v_30];
+    record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_655: usize = 2;
-const IN_655: usize = 2;
-const OUT_655: usize = 1;
-fn aiur_fn_655(
-  inp: [G; IN_655],
+const INPUT_SIZE_658: usize = 2;
+const IN_658: usize = 2;
+const OUT_658: usize = 1;
+fn aiur_fn_658(
+  inp: [G; IN_658],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_655], ExecError> {
+) -> Result<[G; OUT_658], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55712,14 +55155,14 @@ fn aiur_fn_655(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_655] = [__v_8];
-            record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_655] = [__v_8];
-            record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55732,19 +55175,19 @@ fn aiur_fn_655(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_655] = [__v_8];
-            record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_3, __v_6]; 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_655] = [__v_10];
-            record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_10];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55759,15 +55202,15 @@ fn aiur_fn_655(
   })
 }
 
-const INPUT_SIZE_656: usize = 6;
-const IN_656: usize = 6;
-const OUT_656: usize = 1;
-fn aiur_fn_656(
-  inp: [G; IN_656],
+const INPUT_SIZE_659: usize = 6;
+const IN_659: usize = 6;
+const OUT_659: usize = 1;
+fn aiur_fn_659(
+  inp: [G; IN_659],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_656], ExecError> {
+) -> Result<[G; OUT_659], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55779,14 +55222,14 @@ fn aiur_fn_656(
       _ => {
         match __v_3.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_4]; 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_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_5]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_5]; 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 __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_6, __v_7]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_6, __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_656] = [__v_8];
-            record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_659] = [__v_8];
+            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55795,15 +55238,15 @@ fn aiur_fn_656(
   })
 }
 
-const INPUT_SIZE_657: usize = 2;
-const IN_657: usize = 2;
-const OUT_657: usize = 1;
-fn aiur_fn_657(
-  inp: [G; IN_657],
+const INPUT_SIZE_660: usize = 2;
+const IN_660: usize = 2;
+const OUT_660: usize = 1;
+fn aiur_fn_660(
+  inp: [G; IN_660],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_657], ExecError> {
+) -> Result<[G; OUT_660], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55824,14 +55267,14 @@ fn aiur_fn_657(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_12: G = G::from_u64(1);
-            let __ret: [G; OUT_657] = [__v_12];
-            record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_660] = [__v_12];
+            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(0);
-            let __ret: [G; OUT_657] = [__v_12];
-            record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_660] = [__v_12];
+            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55846,19 +55289,19 @@ fn aiur_fn_657(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_12: G = G::from_u64(2);
-            let __ret: [G; OUT_657] = [__v_12];
-            record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_660] = [__v_12];
+            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; 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 __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; 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_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_6, __v_11]; 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 __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_6, __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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_12, __v_13]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_12, __v_13]; 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_14: G = __r_arr[0];
-            let __ret: [G; OUT_657] = [__v_14];
-            record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_660] = [__v_14];
+            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55873,15 +55316,15 @@ fn aiur_fn_657(
   })
 }
 
-const INPUT_SIZE_658: usize = 8;
-const IN_658: usize = 8;
-const OUT_658: usize = 2;
-fn aiur_fn_658(
-  inp: [G; IN_658],
+const INPUT_SIZE_661: usize = 8;
+const IN_661: usize = 8;
+const OUT_661: usize = 2;
+fn aiur_fn_661(
+  inp: [G; IN_661],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_658], ExecError> {
+) -> Result<[G; OUT_661], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55895,19 +55338,19 @@ fn aiur_fn_658(
       _ => {
         match __v_3.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_4]; 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_8]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_8]; 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 __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_5, __v_6, __v_7]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_5, __v_6, __v_7]; 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_9, __v_10, __v_11, __v_12]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_658] = [__v_13, __v_14];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_661] = [__v_13, __v_14];
+            record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55916,15 +55359,15 @@ fn aiur_fn_658(
   })
 }
 
-const INPUT_SIZE_659: usize = 4;
-const IN_659: usize = 4;
-const OUT_659: usize = 2;
-fn aiur_fn_659(
-  inp: [G; IN_659],
+const INPUT_SIZE_662: usize = 4;
+const IN_662: usize = 4;
+const OUT_662: usize = 2;
+fn aiur_fn_662(
+  inp: [G; IN_662],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_659], ExecError> {
+) -> Result<[G; OUT_662], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55946,19 +55389,19 @@ fn aiur_fn_659(
         let __v_13: G = __loaded[4];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = []; 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = []; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_659] = [__v_14, __v_15];
-            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_662] = [__v_14, __v_15];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = []; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = []; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_659] = [__v_14, __v_15];
-            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_662] = [__v_14, __v_15];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55972,25 +55415,25 @@ fn aiur_fn_659(
         let __v_13: G = __loaded[4];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = []; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = []; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_659] = [__v_14, __v_15];
-            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_662] = [__v_14, __v_15];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_5, __v_6, __v_7, __v_10, __v_11, __v_12, __v_2, __v_3]; 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 __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_5, __v_6, __v_7, __v_10, __v_11, __v_12, __v_2, __v_3]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_8, __v_13, __v_2, __v_3]; 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 __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_8, __v_13, __v_2, __v_3]; 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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_14, __v_15, __v_16, __v_17]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_14, __v_15, __v_16, __v_17]; 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_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_659] = [__v_18, __v_19];
-            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_662] = [__v_18, __v_19];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56005,15 +55448,15 @@ fn aiur_fn_659(
   })
 }
 
-const INPUT_SIZE_660: usize = 11;
-const IN_660: usize = 11;
-const OUT_660: usize = 1;
-fn aiur_fn_660(
-  inp: [G; IN_660],
+const INPUT_SIZE_663: usize = 11;
+const IN_663: usize = 11;
+const OUT_663: usize = 1;
+fn aiur_fn_663(
+  inp: [G; IN_663],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_660], ExecError> {
+) -> Result<[G; OUT_663], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56029,50 +55472,50 @@ fn aiur_fn_660(
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_660] = [__v_11];
-        record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_663] = [__v_11];
+        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_660] = [__v_11];
-        record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_663] = [__v_11];
+        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_660] = [__v_11];
-        record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_663] = [__v_11];
+        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_11: G = G::from_u64(1);
-        let __ret: [G; OUT_660] = [__v_11];
-        record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_663] = [__v_11];
+        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_11: G = G::from_u64(2);
-        let __ret: [G; OUT_660] = [__v_11];
-        record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_663] = [__v_11];
+        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_11: G = G::from_u64(3);
-        let __ret: [G; OUT_660] = [__v_11];
-        record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_663] = [__v_11];
+        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_11: G = G::from_u64(4);
-        let __ret: [G; OUT_660] = [__v_11];
-        record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_663] = [__v_11];
+        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_11: G = G::from_u64(5);
-        let __ret: [G; OUT_660] = [__v_11];
-        record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_663] = [__v_11];
+        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -56082,15 +55525,15 @@ fn aiur_fn_660(
   })
 }
 
-const INPUT_SIZE_661: usize = 22;
-const IN_661: usize = 22;
-const OUT_661: usize = 1;
-fn aiur_fn_661(
-  inp: [G; IN_661],
+const INPUT_SIZE_664: usize = 22;
+const IN_664: usize = 22;
+const OUT_664: usize = 1;
+fn aiur_fn_664(
+  inp: [G; IN_664],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_661], ExecError> {
+) -> Result<[G; OUT_664], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56114,38 +55557,38 @@ fn aiur_fn_661(
     let __v_19: G = inp[19];
     let __v_20: G = inp[20];
     let __v_21: G = inp[21];
-    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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 __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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[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_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__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[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 __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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[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_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_22, __v_23]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_22, __v_23]; 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_24: G = __r_arr[0];
     match __v_24.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __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[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 __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __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[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_25: G = __r_arr[0];
-        let __ret: [G; OUT_661] = [__v_25];
-        record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_664] = [__v_25];
+        record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_661] = [__v_24];
-        record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_664] = [__v_24];
+        record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_662: usize = 22;
-const IN_662: usize = 22;
-const OUT_662: usize = 1;
-fn aiur_fn_662(
-  inp: [G; IN_662],
+const INPUT_SIZE_665: usize = 22;
+const IN_665: usize = 22;
+const OUT_665: usize = 1;
+fn aiur_fn_665(
+  inp: [G; IN_665],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_662], ExecError> {
+) -> Result<[G; OUT_665], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56173,18 +55616,18 @@ fn aiur_fn_662(
       1u64 => {
         match __v_11.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_13]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_13]; 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 __v_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_3, __v_14]; 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 __v_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_23, __v_24]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_23, __v_24]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_22, __v_25]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_22, __v_25]; 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_26: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_26];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_665] = [__v_26];
+            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56195,18 +55638,18 @@ fn aiur_fn_662(
       2u64 => {
         match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_13]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_13]; 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 __v_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_3, __v_14]; 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 __v_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_23, __v_24]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_23, __v_24]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_22, __v_25]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_22, __v_25]; 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_26: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_26];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_665] = [__v_26];
+            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56217,22 +55660,22 @@ fn aiur_fn_662(
       3u64 => {
         match __v_11.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_13]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_13]; 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 __v_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_3, __v_14]; 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 __v_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_15]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_15]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_24, __v_25]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_24, __v_25]; 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_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_23, __v_26]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_23, __v_26]; 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_22, __v_27]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_22, __v_27]; 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_28: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_28];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_665] = [__v_28];
+            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56243,14 +55686,14 @@ fn aiur_fn_662(
       4u64 => {
         match __v_11.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_13]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_13]; 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 __v_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_22, __v_23]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_22, __v_23]; 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_24: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_24];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_665] = [__v_24];
+            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56261,18 +55704,18 @@ fn aiur_fn_662(
       0u64 => {
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_13]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_13]; 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 __v_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_3, __v_14]; 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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_23, __v_24]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_23, __v_24]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_22, __v_25]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_22, __v_25]; 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_26: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_26];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_665] = [__v_26];
+            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56283,34 +55726,34 @@ fn aiur_fn_662(
       5u64 => {
         match __v_11.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_17]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_6, __v_17]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_3, __v_14]; 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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_15]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_15]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5]; 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_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
             let __v_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_26, __v_27]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_26, __v_27]; 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_13]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_13]; 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 __v_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_28, __v_29]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_28, __v_29]; 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_30: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_25, __v_30]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_25, __v_30]; 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_24, __v_31]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_24, __v_31]; 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_32: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_23, __v_32]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_23, __v_32]; 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_33: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_22, __v_33]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_22, __v_33]; 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_34: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_34];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_665] = [__v_34];
+            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56321,26 +55764,26 @@ fn aiur_fn_662(
       6u64 => {
         match __v_11.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_15]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_15]; 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_16]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_5, __v_16]; 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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_17]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_6, __v_17]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_13]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_13]; 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 __v_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_25, __v_26]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_25, __v_26]; 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_24, __v_27]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_24, __v_27]; 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_23, __v_28]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_23, __v_28]; 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_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_22, __v_29]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_22, __v_29]; 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_30: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_30];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_665] = [__v_30];
+            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56351,38 +55794,38 @@ fn aiur_fn_662(
       7u64 => {
         match __v_11.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_3, __v_14]; 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_15]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_15]; 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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_16]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_5, __v_16]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_17]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_6, __v_17]; 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_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_8, __v_19]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_8, __v_19]; 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_2, __v_13]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_2, __v_13]; 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 __v_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_7, __v_18]; 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 __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_7, __v_18]; 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_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_28, __v_29]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_28, __v_29]; 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_30: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_27, __v_30]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_27, __v_30]; 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_26, __v_31]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_26, __v_31]; 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_32: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_25, __v_32]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_25, __v_32]; 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_33: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_24, __v_33]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_24, __v_33]; 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_23, __v_34]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_23, __v_34]; 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_35: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_22, __v_35]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_22, __v_35]; 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_36: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_36];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_665] = [__v_36];
+            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56397,15 +55840,15 @@ fn aiur_fn_662(
   })
 }
 
-const INPUT_SIZE_663: usize = 25;
-const IN_663: usize = 25;
-const OUT_663: usize = 2;
-fn aiur_fn_663(
-  inp: [G; IN_663],
+const INPUT_SIZE_666: usize = 25;
+const IN_666: usize = 25;
+const OUT_666: usize = 2;
+fn aiur_fn_666(
+  inp: [G; IN_666],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_663], ExecError> {
+) -> Result<[G; OUT_666], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56432,42 +55875,42 @@ fn aiur_fn_663(
     let __v_22: G = inp[22];
     let __v_23: G = inp[23];
     let __v_24: G = inp[24];
-    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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 __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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[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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__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[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 __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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[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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_25, __v_26]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_25, __v_26]; 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_27: G = __r_arr[0];
     match __v_27.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
-        let __ret: [G; OUT_663] = [__v_28, __v_29];
-        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_666] = [__v_28, __v_29];
+        record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_27]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_27]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
-        let __ret: [G; OUT_663] = [__v_28, __v_29];
-        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_666] = [__v_28, __v_29];
+        record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_664: usize = 25;
-const IN_664: usize = 25;
-const OUT_664: usize = 2;
-fn aiur_fn_664(
-  inp: [G; IN_664],
+const INPUT_SIZE_667: usize = 25;
+const IN_667: usize = 25;
+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_664], ExecError> {
+) -> Result<[G; OUT_667], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56498,25 +55941,25 @@ fn aiur_fn_664(
       1u64 => {
         match __v_11.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_25]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_13, __v_22, __v_24]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_13, __v_22, __v_24]; 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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_3, __v_14, __v_22, __v_24]; 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_652] = { let __args: [G; IN_652] = [__v_3, __v_14, __v_22, __v_24]; 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_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_28, __v_29, __v_30, __v_31]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_28, __v_29, __v_30, __v_31]; 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_26, __v_27, __v_32, __v_33]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_26, __v_27, __v_32, __v_33]; 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_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_34, __v_35];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_667] = [__v_34, __v_35];
+            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56527,25 +55970,25 @@ fn aiur_fn_664(
       2u64 => {
         match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_25]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_13, __v_22, __v_24]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_13, __v_22, __v_24]; 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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_3, __v_14, __v_22, __v_24]; 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_652] = { let __args: [G; IN_652] = [__v_3, __v_14, __v_22, __v_24]; 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_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_28, __v_29, __v_30, __v_31]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_28, __v_29, __v_30, __v_31]; 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_26, __v_27, __v_32, __v_33]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_26, __v_27, __v_32, __v_33]; 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_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_34, __v_35];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_667] = [__v_34, __v_35];
+            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56556,33 +55999,33 @@ fn aiur_fn_664(
       3u64 => {
         match __v_11.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_25]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_13, __v_22, __v_24]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_13, __v_22, __v_24]; 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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_3, __v_14, __v_22, __v_24]; 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_652] = { let __args: [G; IN_652] = [__v_3, __v_14, __v_22, __v_24]; 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_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_15]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_15]; 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_32: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_32]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_32]; 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_33: G = __r_arr[0];
             let __v_34: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_30, __v_31, __v_33, __v_34]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_30, __v_31, __v_33, __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 __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_28, __v_29, __v_35, __v_36]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_28, __v_29, __v_35, __v_36]; 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_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_26, __v_27, __v_37, __v_38]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_26, __v_27, __v_37, __v_38]; 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_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_39, __v_40];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_667] = [__v_39, __v_40];
+            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56593,19 +56036,19 @@ fn aiur_fn_664(
       4u64 => {
         match __v_11.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_25]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_13, __v_22, __v_24]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_13, __v_22, __v_24]; 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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_26, __v_27, __v_28, __v_29]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_26, __v_27, __v_28, __v_29]; 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_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_30, __v_31];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_667] = [__v_30, __v_31];
+            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56616,27 +56059,27 @@ fn aiur_fn_664(
       0u64 => {
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_25]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_13, __v_22, __v_24]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_13, __v_22, __v_24]; 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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_3, __v_14]; 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_30: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_30]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_30]; 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_31: G = __r_arr[0];
             let __v_32: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_28, __v_29, __v_31, __v_32]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_28, __v_29, __v_31, __v_32]; 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_33: G = __r_arr[0];
             let __v_34: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_26, __v_27, __v_33, __v_34]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_26, __v_27, __v_33, __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 __v_36: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_35, __v_36];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_667] = [__v_35, __v_36];
+            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56647,61 +56090,61 @@ fn aiur_fn_664(
       5u64 => {
         match __v_11.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_17]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_6, __v_17]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_25]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_28]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_28]; 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_3, __v_14]; 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_31]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_31]; 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_15]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_15]; 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_34]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_34]; 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5]; 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_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
             let __v_38: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_37, __v_38]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_37, __v_38]; 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_39: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_39]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_39]; 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_40: G = __r_arr[0];
             let __v_41: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_13, __v_22, __v_24]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_13, __v_22, __v_24]; 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_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_5, __v_16, __v_22, __v_23, __v_24]; 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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_5, __v_16, __v_22, __v_23, __v_24]; 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_44: G = __r_arr[0];
             let __v_45: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_42, __v_43, __v_44, __v_45]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_42, __v_43, __v_44, __v_45]; 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_46: G = __r_arr[0];
             let __v_47: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_40, __v_41, __v_46, __v_47]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_40, __v_41, __v_46, __v_47]; 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_48: G = __r_arr[0];
             let __v_49: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_35, __v_36, __v_48, __v_49]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_35, __v_36, __v_48, __v_49]; 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_50: G = __r_arr[0];
             let __v_51: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_32, __v_33, __v_50, __v_51]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_32, __v_33, __v_50, __v_51]; 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_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_29, __v_30, __v_52, __v_53]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_29, __v_30, __v_52, __v_53]; 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_54: G = __r_arr[0];
             let __v_55: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_26, __v_27, __v_54, __v_55]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_26, __v_27, __v_54, __v_55]; 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_56: G = __r_arr[0];
             let __v_57: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_56, __v_57];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_667] = [__v_56, __v_57];
+            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56712,43 +56155,43 @@ fn aiur_fn_664(
       6u64 => {
         match __v_11.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_25]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_15]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_15]; 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_28]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_28]; 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_16]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_5, __v_16]; 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_31]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_31]; 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_17]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_6, __v_17]; 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_34]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_34]; 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_13, __v_22, __v_24]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_13, __v_22, __v_24]; 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_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_35, __v_36, __v_37, __v_38]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_35, __v_36, __v_37, __v_38]; 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_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_32, __v_33, __v_39, __v_40]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_32, __v_33, __v_39, __v_40]; 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_41: G = __r_arr[0];
             let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_29, __v_30, __v_41, __v_42]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_29, __v_30, __v_41, __v_42]; 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_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_26, __v_27, __v_43, __v_44]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_26, __v_27, __v_43, __v_44]; 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_45: G = __r_arr[0];
             let __v_46: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_45, __v_46];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_667] = [__v_45, __v_46];
+            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56759,65 +56202,65 @@ fn aiur_fn_664(
       7u64 => {
         match __v_11.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_25]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_3, __v_14]; 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_28]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_28]; 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_15]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_15]; 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_31]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_31]; 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_16]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_5, __v_16]; 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_34]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_34]; 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_17]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_6, __v_17]; 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_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_37]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_37]; 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_38: G = __r_arr[0];
             let __v_39: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_8, __v_19]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_8, __v_19]; 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_40: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_40]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_40]; 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_41: G = __r_arr[0];
             let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_13, __v_22, __v_24]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_13, __v_22, __v_24]; 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_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_7, __v_18, __v_22, __v_24]; 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 __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_7, __v_18, __v_22, __v_24]; 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_45: G = __r_arr[0];
             let __v_46: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_43, __v_44, __v_45, __v_46]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_43, __v_44, __v_45, __v_46]; 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_47: G = __r_arr[0];
             let __v_48: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_41, __v_42, __v_47, __v_48]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_41, __v_42, __v_47, __v_48]; 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_49: G = __r_arr[0];
             let __v_50: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_38, __v_39, __v_49, __v_50]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_38, __v_39, __v_49, __v_50]; 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_51: G = __r_arr[0];
             let __v_52: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_35, __v_36, __v_51, __v_52]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_35, __v_36, __v_51, __v_52]; 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_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_32, __v_33, __v_53, __v_54]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_32, __v_33, __v_53, __v_54]; 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_55: G = __r_arr[0];
             let __v_56: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_29, __v_30, __v_55, __v_56]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_29, __v_30, __v_55, __v_56]; 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_57: G = __r_arr[0];
             let __v_58: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_26, __v_27, __v_57, __v_58]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_26, __v_27, __v_57, __v_58]; 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_59: G = __r_arr[0];
             let __v_60: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_59, __v_60];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_667] = [__v_59, __v_60];
+            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56832,15 +56275,15 @@ fn aiur_fn_664(
   })
 }
 
-const INPUT_SIZE_665: usize = 5;
-const IN_665: usize = 5;
-const OUT_665: usize = 2;
-fn aiur_fn_665(
-  inp: [G; IN_665],
+const INPUT_SIZE_668: usize = 5;
+const IN_668: usize = 5;
+const OUT_668: usize = 2;
+fn aiur_fn_668(
+  inp: [G; IN_668],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_665], ExecError> {
+) -> Result<[G; OUT_668], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56853,11 +56296,11 @@ fn aiur_fn_665(
     let __v_7: G = __loaded[2];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = []; 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = []; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_665] = [__v_8, __v_9];
-        record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_668] = [__v_8, __v_9];
+        record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -56867,15 +56310,15 @@ fn aiur_fn_665(
         let __v_10: G = __loaded[2];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = []; 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = []; 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_665] = [__v_11, __v_12];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_668] = [__v_11, __v_12];
+            record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __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];
@@ -56889,7 +56332,7 @@ fn aiur_fn_665(
             let __v_20: G = __loaded[8];
             let __v_21: G = __loaded[9];
             let __v_22: G = __loaded[10];
-            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
             let __v_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];
@@ -56903,17 +56346,17 @@ fn aiur_fn_665(
             let __v_32: G = __loaded[8];
             let __v_33: G = __loaded[9];
             let __v_34: G = __loaded[10];
-            let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_2, __v_4]; 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 __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_2, __v_4]; 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_7, __v_10, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_7, __v_10, __v_2, __v_3, __v_4]; 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_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_35, __v_36, __v_37, __v_38]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_35, __v_36, __v_37, __v_38]; 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_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __ret: [G; OUT_665] = [__v_39, __v_40];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_668] = [__v_39, __v_40];
+            record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56928,15 +56371,15 @@ fn aiur_fn_665(
   })
 }
 
-const INPUT_SIZE_666: usize = 24;
-const IN_666: usize = 24;
-const OUT_666: usize = 2;
-fn aiur_fn_666(
-  inp: [G; IN_666],
+const INPUT_SIZE_669: usize = 24;
+const IN_669: usize = 24;
+const OUT_669: usize = 2;
+fn aiur_fn_669(
+  inp: [G; IN_669],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_666], ExecError> {
+) -> Result<[G; OUT_669], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56966,88 +56409,88 @@ fn aiur_fn_666(
       6u64 => {
         match __v_11.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_12]; 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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_24]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_24]; 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_25: G = __r_arr[0];
             let __v_26: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_15]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_15]; 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_27]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_27]; 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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_16]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_5, __v_16]; 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_30: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_30]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_30]; 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_31: G = __r_arr[0];
             let __v_32: G = __r_arr[1];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_17]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_6, __v_17]; 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_33: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_33]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_33]; 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_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2, __v_13, __v_22, __v_23]; 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_652] = { let __args: [G; IN_652] = [__v_2, __v_13, __v_22, __v_23]; 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_36: G = __r_arr[0];
             let __v_37: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_34, __v_35, __v_36, __v_37]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_34, __v_35, __v_36, __v_37]; 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_38: G = __r_arr[0];
             let __v_39: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_31, __v_32, __v_38, __v_39]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_31, __v_32, __v_38, __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 = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_28, __v_29, __v_40, __v_41]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_28, __v_29, __v_40, __v_41]; 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_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_25, __v_26, __v_42, __v_43]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_25, __v_26, __v_42, __v_43]; 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_44: G = __r_arr[0];
             let __v_45: G = __r_arr[1];
-            let __ret: [G; OUT_666] = [__v_44, __v_45];
-            record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_669] = [__v_44, __v_45];
+            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_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[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 __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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[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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__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[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 __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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[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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_24, __v_25]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_24, __v_25]; 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_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_26]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_26]; 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_27: G = __r_arr[0];
             let __v_28: G = __r_arr[1];
-            let __ret: [G; OUT_666] = [__v_27, __v_28];
-            record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_669] = [__v_27, __v_28];
+            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_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[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 __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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[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_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__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[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 __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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[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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_24, __v_25]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_24, __v_25]; 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_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_26]; 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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_26]; 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_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
-        let __ret: [G; OUT_666] = [__v_27, __v_28];
-        record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_669] = [__v_27, __v_28];
+        record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_667: usize = 4;
-const IN_667: usize = 4;
-const OUT_667: usize = 1;
-fn aiur_fn_667(
-  inp: [G; IN_667],
+const INPUT_SIZE_670: usize = 4;
+const IN_670: usize = 4;
+const OUT_670: usize = 1;
+fn aiur_fn_670(
+  inp: [G; IN_670],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_667], ExecError> {
+) -> Result<[G; OUT_670], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57062,8 +56505,8 @@ fn aiur_fn_667(
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
         let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_667] = [__v_9];
-        record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_670] = [__v_9];
+        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -57079,25 +56522,25 @@ fn aiur_fn_667(
         let __v_15: G = __loaded[8];
         let __v_16: G = __loaded[9];
         let __v_17: G = __loaded[10];
-        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__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[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 __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__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[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_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_667] = { let __args: [G; IN_667] = [__v_0, __v_6, __v_2, __v_20]; 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 __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_6, __v_2, __v_20]; 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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_18, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_18, __v_0]; 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_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_667] = [__v_24];
-            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_670] = [__v_24];
+            record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __ret: [G; OUT_667] = [__v_21];
-            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_670] = [__v_21];
+            record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -57112,15 +56555,15 @@ fn aiur_fn_667(
   })
 }
 
-const INPUT_SIZE_668: usize = 2;
-const IN_668: usize = 2;
-const OUT_668: usize = 0;
-fn aiur_fn_668(
-  inp: [G; IN_668],
+const INPUT_SIZE_671: usize = 2;
+const IN_671: usize = 2;
+const OUT_671: usize = 0;
+fn aiur_fn_671(
+  inp: [G; IN_671],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_668], ExecError> {
+) -> Result<[G; OUT_671], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57161,22 +56604,22 @@ fn aiur_fn_668(
     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 __v_38: G = G::from_u64(0);
-    let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_34, __v_37, __v_38, __v_0, __v_1]; 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 __ret: [G; OUT_668] = [];
-    record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_0, __v_34, __v_37, __v_38, __v_0, __v_1]; 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 __ret: [G; OUT_671] = [];
+    record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_669: usize = 12;
-const IN_669: usize = 12;
-const OUT_669: usize = 1;
-fn aiur_fn_669(
-  inp: [G; IN_669],
+const INPUT_SIZE_672: usize = 12;
+const IN_672: usize = 12;
+const OUT_672: usize = 1;
+fn aiur_fn_672(
+  inp: [G; IN_672],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_669], ExecError> {
+) -> Result<[G; OUT_672], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57192,12 +56635,12 @@ fn aiur_fn_669(
     let __v_11: G = inp[11];
     match __v_0.as_canonical_u64() {
       5u64 => {
-        let __ret: [G; OUT_669] = [__v_7];
-        record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_672] = [__v_7];
+        record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __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];
@@ -57213,8 +56656,8 @@ fn aiur_fn_669(
         let __v_23: G = __loaded[10];
         match __v_13.as_canonical_u64() {
           5u64 => {
-            let __ret: [G; OUT_669] = [__v_20];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_672] = [__v_20];
+            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -57251,15 +56694,15 @@ fn aiur_fn_669(
             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_669] = [__v_56];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_672] = [__v_56];
+            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       7u64 => {
-        let __ret: [G; OUT_669] = [__v_10];
-        record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_672] = [__v_10];
+        record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -57296,23 +56739,23 @@ fn aiur_fn_669(
         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_669] = [__v_44];
-        record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_672] = [__v_44];
+        record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_670: usize = 6;
-const IN_670: usize = 6;
-const OUT_670: usize = 0;
-fn aiur_fn_670(
-  inp: [G; IN_670],
+const INPUT_SIZE_673: usize = 6;
+const IN_673: usize = 6;
+const OUT_673: usize = 0;
+fn aiur_fn_673(
+  inp: [G; IN_673],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_670], ExecError> {
+) -> Result<[G; OUT_673], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57326,9 +56769,9 @@ fn aiur_fn_670(
     let __v_8: G = __loaded[2];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_1, __v_2, __v_4, __v_5]; 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 __ret: [G; OUT_670] = [];
-        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_1, __v_2, __v_4, __v_5]; 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 __ret: [G; OUT_673] = [];
+        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -57344,30 +56787,30 @@ fn aiur_fn_670(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_20, __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 __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_20, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         match __v_21.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
             let __v_23: G = G::from_u64(1);
             let __v_24: G = (__v_3 + __v_23);
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_8, __v_20, __v_22, __v_24, __v_4, __v_5]; 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 __ret: [G; OUT_670] = [];
-            record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_8, __v_20, __v_22, __v_24, __v_4, __v_5]; 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 __ret: [G; OUT_673] = [];
+            record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_1, __v_2, __v_4, __v_5]; 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 __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_20, __v_3]; 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 __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_1, __v_2, __v_4, __v_5]; 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 __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_20, __v_3]; 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_22: G = __r_arr[0];
             let __v_23: G = G::from_u64(1);
             let __v_24: G = (__v_3 + __v_23);
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_8, __v_20, __v_22, __v_24, __v_4, __v_5]; 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 __ret: [G; OUT_670] = [];
-            record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_8, __v_20, __v_22, __v_24, __v_4, __v_5]; 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 __ret: [G; OUT_673] = [];
+            record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -57382,15 +56825,15 @@ fn aiur_fn_670(
   })
 }
 
-const INPUT_SIZE_671: usize = 2;
-const IN_671: usize = 2;
-const OUT_671: usize = 1;
-fn aiur_fn_671(
-  inp: [G; IN_671],
+const INPUT_SIZE_674: usize = 2;
+const IN_674: usize = 2;
+const OUT_674: usize = 1;
+fn aiur_fn_674(
+  inp: [G; IN_674],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_671], ExecError> {
+) -> Result<[G; OUT_674], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57427,15 +56870,15 @@ fn aiur_fn_671(
     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_126] = { let __args: [G; IN_126] = [__v_0, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_34]; 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_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_671] = [__v_38];
-        record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_674] = [__v_38];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -57444,8 +56887,8 @@ fn aiur_fn_671(
         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_671] = [__v_40];
-        record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_674] = [__v_40];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -57455,15 +56898,15 @@ fn aiur_fn_671(
   })
 }
 
-const INPUT_SIZE_672: usize = 4;
-const IN_672: usize = 4;
-const OUT_672: usize = 0;
-fn aiur_fn_672(
-  inp: [G; IN_672],
+const INPUT_SIZE_675: usize = 4;
+const IN_675: usize = 4;
+const OUT_675: usize = 0;
+fn aiur_fn_675(
+  inp: [G; IN_675],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_672], ExecError> {
+) -> Result<[G; OUT_675], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57502,32 +56945,32 @@ fn aiur_fn_672(
     let __v_34: G = G::from_u64(0);
     let __v_35: G = G::from_u64(0);
     let __v_36: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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 __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_36]; 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_37: G = __r_arr[0];
     match __v_37.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_672] = [];
-        record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_675] = [];
+        record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; 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_38: G = __r_arr[0];
         match __v_38.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_672] = [];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_675] = [];
+            record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __ret: [G; OUT_672] = [];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_675] = [];
+            record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_1, __v_2, __v_3]; 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 __ret: [G; OUT_672] = [];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_1, __v_2, __v_3]; 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 __ret: [G; OUT_675] = [];
+            record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -57539,42 +56982,42 @@ fn aiur_fn_672(
   })
 }
 
-const INPUT_SIZE_673: usize = 3;
-const IN_673: usize = 3;
-const OUT_673: usize = 0;
-fn aiur_fn_673(
-  inp: [G; IN_673],
+const INPUT_SIZE_676: usize = 3;
+const IN_676: usize = 3;
+const OUT_676: usize = 0;
+fn aiur_fn_676(
+  inp: [G; IN_676],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_673], ExecError> {
+) -> Result<[G; OUT_676], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_0, __v_1]; 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 __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_673] = [];
-        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_676] = [];
+        record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __ret: [G; OUT_673] = [];
-        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_676] = [];
+        record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_3, __v_1, __v_2]; 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_1, __v_2]; 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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_5]; 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 __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_5]; 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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_5]; 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 __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_7, __v_3]; 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 __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_7, __v_3]; 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_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         if (__v_6 != __v_9) {
@@ -57584,23 +57027,23 @@ fn aiur_fn_673(
         if (__v_8 != __v_10) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
         }
-        let __ret: [G; OUT_673] = [];
-        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_676] = [];
+        record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_674: usize = 2;
-const IN_674: usize = 2;
-const OUT_674: usize = 1;
-fn aiur_fn_674(
-  inp: [G; IN_674],
+const INPUT_SIZE_677: usize = 2;
+const IN_677: usize = 2;
+const OUT_677: usize = 1;
+fn aiur_fn_677(
+  inp: [G; IN_677],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_674], ExecError> {
+) -> Result<[G; OUT_677], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57613,12 +57056,12 @@ fn aiur_fn_674(
         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_674] = [__v_7];
-        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_677] = [__v_7];
+        record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -57632,21 +57075,21 @@ fn aiur_fn_674(
         let __v_14: G = __loaded[8];
         let __v_15: G = __loaded[9];
         let __v_16: G = __loaded[10];
-        let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_1]; 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 __v_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__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[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 __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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[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_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_674] = [__v_20];
-            record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_677] = [__v_20];
+            record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_674] = [__v_17];
-            record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_677] = [__v_17];
+            record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -57658,15 +57101,15 @@ fn aiur_fn_674(
   })
 }
 
-const INPUT_SIZE_675: usize = 1;
-const IN_675: usize = 1;
-const OUT_675: usize = 1;
-fn aiur_fn_675(
-  inp: [G; IN_675],
+const INPUT_SIZE_678: usize = 1;
+const IN_678: usize = 1;
+const OUT_678: usize = 1;
+fn aiur_fn_678(
+  inp: [G; IN_678],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_675], ExecError> {
+) -> Result<[G; OUT_678], 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 };
@@ -57676,25 +57119,25 @@ fn aiur_fn_675(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_675] = [__v_4];
-        record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_678] = [__v_4];
+        record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2]; 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_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_3]; 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 __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__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 __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_675] = [__v_5];
-            record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_5];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_5: G = G::from_u64(0);
-            let __ret: [G; OUT_675] = [__v_5];
-            record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_5];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -57706,15 +57149,15 @@ fn aiur_fn_675(
   })
 }
 
-const INPUT_SIZE_676: usize = 1;
-const IN_676: usize = 1;
-const OUT_676: usize = 1;
-fn aiur_fn_676(
-  inp: [G; IN_676],
+const INPUT_SIZE_679: usize = 1;
+const IN_679: usize = 1;
+const OUT_679: usize = 1;
+fn aiur_fn_679(
+  inp: [G; IN_679],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_676], ExecError> {
+) -> Result<[G; OUT_679], 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 };
@@ -57726,17 +57169,17 @@ fn aiur_fn_676(
         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_676] = [__v_6];
-        record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_679] = [__v_6];
+        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_3]; 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 __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__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 __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_676] = [__v_5];
-        record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_679] = [__v_5];
+        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -57746,15 +57189,15 @@ fn aiur_fn_676(
   })
 }
 
-const INPUT_SIZE_677: usize = 3;
-const IN_677: usize = 3;
-const OUT_677: usize = 1;
-fn aiur_fn_677(
-  inp: [G; IN_677],
+const INPUT_SIZE_680: usize = 3;
+const IN_680: usize = 3;
+const OUT_680: usize = 1;
+fn aiur_fn_680(
+  inp: [G; IN_680],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_677], ExecError> {
+) -> Result<[G; OUT_680], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57765,26 +57208,26 @@ fn aiur_fn_677(
     let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_8: G = G::from_u64(1);
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_9: G = __r_arr[0];
     let __v_10: G = (__v_8 + __v_9);
-    let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_7, __v_1, __v_2, __v_10]; 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_681] = { let __args: [G; IN_681] = [__v_7, __v_1, __v_2, __v_10]; 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 __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_677] = [__v_11];
-    record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_680] = [__v_11];
+    record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_678: usize = 4;
-const IN_678: usize = 4;
-const OUT_678: usize = 1;
-fn aiur_fn_678(
-  inp: [G; IN_678],
+const INPUT_SIZE_681: usize = 4;
+const IN_681: usize = 4;
+const OUT_681: usize = 1;
+fn aiur_fn_681(
+  inp: [G; IN_681],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_678], ExecError> {
+) -> Result<[G; OUT_681], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57792,30 +57235,30 @@ fn aiur_fn_678(
     let __v_3: G = inp[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_678] = [__v_0];
-        record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_681] = [__v_0];
+        record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_0, __v_1]; 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_682] = { let __args: [G; IN_682] = [__v_0, __v_1]; 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 __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_0, __v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_4, __v_1, __v_2]; 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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_5]; 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 __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0, __v_5]; 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];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_678] = [__v_0];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_681] = [__v_0];
+            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_3 - __v_7);
-            let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_5, __v_1, __v_2, __v_8]; 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_681] = { let __args: [G; IN_681] = [__v_5, __v_1, __v_2, __v_8]; 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 __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_678] = [__v_9];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_681] = [__v_9];
+            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -57824,38 +57267,38 @@ fn aiur_fn_678(
   })
 }
 
-const INPUT_SIZE_679: usize = 2;
-const IN_679: usize = 2;
-const OUT_679: usize = 1;
-fn aiur_fn_679(
-  inp: [G; IN_679],
+const INPUT_SIZE_682: usize = 2;
+const IN_682: usize = 2;
+const OUT_682: usize = 1;
+fn aiur_fn_682(
+  inp: [G; IN_682],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_679], ExecError> {
+) -> Result<[G; OUT_682], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_0, __v_1, __v_2, __v_3]; 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_683] = { let __args: [G; IN_683] = [__v_0, __v_1, __v_2, __v_3]; 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 __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_679] = [__v_4];
-    record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_682] = [__v_4];
+    record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_680: usize = 4;
-const IN_680: usize = 4;
-const OUT_680: usize = 1;
-fn aiur_fn_680(
-  inp: [G; IN_680],
+const INPUT_SIZE_683: usize = 4;
+const IN_683: usize = 4;
+const OUT_683: usize = 1;
+fn aiur_fn_683(
+  inp: [G; IN_683],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_680], ExecError> {
+) -> Result<[G; OUT_683], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57870,23 +57313,23 @@ fn aiur_fn_680(
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_680] = [__v_9];
-        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_683] = [__v_9];
+        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_5, __v_1, __v_2, __v_3]; 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 __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
         let __v_11: G = (__v_3 + __v_8);
-        let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_6, __v_1, __v_10, __v_11]; 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_683] = { let __args: [G; IN_683] = [__v_6, __v_1, __v_10, __v_11]; 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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } else { aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_680] = [__v_13];
-        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_683] = [__v_13];
+        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -57896,15 +57339,15 @@ fn aiur_fn_680(
   })
 }
 
-const INPUT_SIZE_681: usize = 4;
-const IN_681: usize = 4;
-const OUT_681: usize = 2;
-fn aiur_fn_681(
-  inp: [G; IN_681],
+const INPUT_SIZE_684: usize = 4;
+const IN_684: usize = 4;
+const OUT_684: usize = 2;
+fn aiur_fn_684(
+  inp: [G; IN_684],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_681], ExecError> {
+) -> Result<[G; OUT_684], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57920,15 +57363,15 @@ fn aiur_fn_681(
         let __v_8: G = G::from_u64(1);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_681] = [__v_9, __v_10];
-        record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_684] = [__v_9, __v_10];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_6, __v_1, __v_2, __v_3]; 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 __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -57942,27 +57385,27 @@ fn aiur_fn_681(
         let __v_18: G = __loaded[8];
         let __v_19: G = __loaded[9];
         let __v_20: G = __loaded[10];
-        let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
         let __v_23: G = G::from_u64(0);
-        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_21, __v_3, __v_23]; 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_685] = { let __args: [G; IN_685] = [__v_21, __v_3, __v_23]; 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 __v_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(0);
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_24, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_24, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } else { aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = { let __values: [G; 4] = [__v_25, __v_5, __v_2, __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 __v_28: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_22.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_28.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_681] = [__v_27, __v_22];
-            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_684] = [__v_27, __v_22];
+            record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_681] = [__v_27, __v_8];
-            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_684] = [__v_27, __v_8];
+            record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -57974,15 +57417,15 @@ fn aiur_fn_681(
   })
 }
 
-const INPUT_SIZE_682: usize = 3;
-const IN_682: usize = 3;
-const OUT_682: usize = 1;
-fn aiur_fn_682(
-  inp: [G; IN_682],
+const INPUT_SIZE_685: usize = 3;
+const IN_685: usize = 3;
+const OUT_685: usize = 1;
+fn aiur_fn_685(
+  inp: [G; IN_685],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_682], ExecError> {
+) -> Result<[G; OUT_685], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57996,8 +57439,8 @@ fn aiur_fn_682(
         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_682] = [__v_8];
-        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_685] = [__v_8];
+        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -58005,11 +57448,11 @@ fn aiur_fn_682(
         let __v_7: G = (__v_1 + __v_2);
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_2 + __v_8);
-        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_5, __v_1, __v_9]; 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_685] = { let __args: [G; IN_685] = [__v_5, __v_1, __v_9]; 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 __v_10: G = __r_arr[0];
         let __v_11: G = { let __values: [G; 4] = [__v_6, __v_4, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_682] = [__v_11];
-        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_685] = [__v_11];
+        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58019,15 +57462,15 @@ fn aiur_fn_682(
   })
 }
 
-const INPUT_SIZE_683: usize = 11;
-const IN_683: usize = 11;
-const OUT_683: usize = 1;
-fn aiur_fn_683(
-  inp: [G; IN_683],
+const INPUT_SIZE_686: usize = 11;
+const IN_686: usize = 11;
+const OUT_686: usize = 1;
+fn aiur_fn_686(
+  inp: [G; IN_686],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_683], ExecError> {
+) -> Result<[G; OUT_686], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58042,31 +57485,31 @@ fn aiur_fn_683(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       5u64 => {
-        let __ret: [G; OUT_683] = [__v_5];
-        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_686] = [__v_5];
+        record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_11: G = G::from_u64(1);
         let __v_12: G = G::from_u64(1);
         let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_683] = [__v_13];
-        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_686] = [__v_13];
+        record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_684: usize = 4;
-const IN_684: usize = 4;
-const OUT_684: usize = 1;
-fn aiur_fn_684(
-  inp: [G; IN_684],
+const INPUT_SIZE_687: usize = 4;
+const IN_687: usize = 4;
+const OUT_687: usize = 1;
+fn aiur_fn_687(
+  inp: [G; IN_687],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_684], ExecError> {
+) -> Result<[G; OUT_687], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58081,19 +57524,19 @@ fn aiur_fn_684(
         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_684] = [__v_9];
-        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_687] = [__v_9];
+        record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_5, __v_1, __v_2, __v_3]; 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_688] = { let __args: [G; IN_688] = [__v_5, __v_1, __v_2, __v_3]; 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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_6, __v_1, __v_2, __v_3]; 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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_684] = [__v_9];
-        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_687] = [__v_9];
+        record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58103,29 +57546,29 @@ fn aiur_fn_684(
   })
 }
 
-const INPUT_SIZE_685: usize = 4;
-const IN_685: usize = 4;
-const OUT_685: usize = 1;
-fn aiur_fn_685(
-  inp: [G; IN_685],
+const INPUT_SIZE_688: usize = 4;
+const IN_688: usize = 4;
+const OUT_688: usize = 1;
+fn aiur_fn_688(
+  inp: [G; IN_688],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_685], ExecError> {
+) -> Result<[G; OUT_688], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
         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_685] = [__v_7];
-        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_688] = [__v_7];
+        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -58134,32 +57577,32 @@ fn aiur_fn_685(
         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_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_685] = [__v_9];
-        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_688] = [__v_9];
+        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0, __v_1, __v_2, __v_3]; 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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_5, __v_1, __v_2, __v_3]; 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_691] = { let __args: [G; IN_691] = [__v_5, __v_1, __v_2, __v_3]; 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_685] = [__v_6];
-        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_688] = [__v_6];
+        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_686: usize = 4;
-const IN_686: usize = 4;
-const OUT_686: usize = 1;
-fn aiur_fn_686(
-  inp: [G; IN_686],
+const INPUT_SIZE_689: usize = 4;
+const IN_689: usize = 4;
+const OUT_689: usize = 1;
+fn aiur_fn_689(
+  inp: [G; IN_689],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_686], ExecError> {
+) -> Result<[G; OUT_689], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58174,17 +57617,17 @@ fn aiur_fn_686(
         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_686] = [__v_9];
-        record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_689] = [__v_9];
+        record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_6, __v_1, __v_2, __v_3]; 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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_5, __v_7, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_5, __v_7, __v_1, __v_2, __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_8: G = __r_arr[0];
-        let __ret: [G; OUT_686] = [__v_8];
-        record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_689] = [__v_8];
+        record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58194,15 +57637,15 @@ fn aiur_fn_686(
   })
 }
 
-const INPUT_SIZE_687: usize = 5;
-const IN_687: usize = 5;
-const OUT_687: usize = 1;
-fn aiur_fn_687(
-  inp: [G; IN_687],
+const INPUT_SIZE_690: usize = 5;
+const IN_690: usize = 5;
+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_687], ExecError> {
+) -> Result<[G; OUT_690], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58220,12 +57663,12 @@ fn aiur_fn_687(
         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_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_687] = [__v_12];
-        record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_690] = [__v_12];
+        record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __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];
@@ -58239,7 +57682,7 @@ fn aiur_fn_687(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -58253,24 +57696,24 @@ fn aiur_fn_687(
         let __v_29: G = __loaded[8];
         let __v_30: G = __loaded[9];
         let __v_31: G = __loaded[10];
-        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__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_2, __v_3, __v_4]; 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_32: G = __r_arr[0];
         let __v_33: G = __r_arr[1];
         match __v_32.as_canonical_u64() {
           0u64 => {
             let __v_34: G = G::from_u64(0);
             let __v_35: G = { let __values: [G; 3] = [__v_34, __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_687] = [__v_35];
-            record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_690] = [__v_35];
+            record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_34: G = G::from_u64(0);
-            let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_7, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_7, __v_2, __v_3, __v_4]; 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_35: G = __r_arr[0];
             let __v_36: G = { let __values: [G; 3] = [__v_34, __v_6, __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 __ret: [G; OUT_687] = [__v_36];
-            record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_690] = [__v_36];
+            record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -58282,15 +57725,15 @@ fn aiur_fn_687(
   })
 }
 
-const INPUT_SIZE_688: usize = 4;
-const IN_688: usize = 4;
-const OUT_688: usize = 1;
-fn aiur_fn_688(
-  inp: [G; IN_688],
+const INPUT_SIZE_691: usize = 4;
+const IN_691: usize = 4;
+const OUT_691: usize = 1;
+fn aiur_fn_691(
+  inp: [G; IN_691],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_688], ExecError> {
+) -> Result<[G; OUT_691], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58305,8 +57748,8 @@ fn aiur_fn_688(
         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_688] = [__v_9];
-        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_691] = [__v_9];
+        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -58315,10 +57758,10 @@ fn aiur_fn_688(
         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_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_6, __v_1, __v_2, __v_3, __v_5, __v_11]; 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 __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_6, __v_1, __v_2, __v_3, __v_5, __v_11]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_688] = [__v_12];
-        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_691] = [__v_12];
+        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58328,15 +57771,15 @@ fn aiur_fn_688(
   })
 }
 
-const INPUT_SIZE_689: usize = 6;
-const IN_689: usize = 6;
-const OUT_689: usize = 1;
-fn aiur_fn_689(
-  inp: [G; IN_689],
+const INPUT_SIZE_692: usize = 6;
+const IN_692: usize = 6;
+const OUT_692: usize = 1;
+fn aiur_fn_692(
+  inp: [G; IN_692],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_689], ExecError> {
+) -> Result<[G; OUT_692], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58355,12 +57798,12 @@ fn aiur_fn_689(
         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 = { let __values: [G; 3] = [__v_9, __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_689] = [__v_13];
-        record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_692] = [__v_13];
+        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -58374,7 +57817,7 @@ fn aiur_fn_689(
         let __v_18: G = __loaded[8];
         let __v_19: G = __loaded[9];
         let __v_20: G = __loaded[10];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_21: 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_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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
         let __v_22: G = __loaded[0];
@@ -58388,17 +57831,17 @@ fn aiur_fn_689(
         let __v_30: G = __loaded[8];
         let __v_31: G = __loaded[9];
         let __v_32: G = __loaded[10];
-        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_1, __v_2, __v_3]; 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_33: G = __r_arr[0];
         let __v_34: G = __r_arr[1];
         match __v_33.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
             let __v_35: G = __r_arr[0];
-            let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_8, __v_1, __v_2, __v_3, __v_7, __v_35]; 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 __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_8, __v_1, __v_2, __v_3, __v_7, __v_35]; 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_36: G = __r_arr[0];
-            let __ret: [G; OUT_689] = [__v_36];
-            record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_692] = [__v_36];
+            record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -58408,11 +57851,11 @@ fn aiur_fn_689(
             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_7, __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_689] = { let __args: [G; IN_689] = [__v_8, __v_1, __v_2, __v_3, __v_7, __v_40]; 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 __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_8, __v_1, __v_2, __v_3, __v_7, __v_40]; 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_41: G = __r_arr[0];
             let __v_42: G = { let __values: [G; 3] = [__v_35, __v_5, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_689] = [__v_42];
-            record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_692] = [__v_42];
+            record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -58424,15 +57867,15 @@ fn aiur_fn_689(
   })
 }
 
-const INPUT_SIZE_690: usize = 2;
-const IN_690: usize = 2;
-const OUT_690: usize = 1;
-fn aiur_fn_690(
-  inp: [G; IN_690],
+const INPUT_SIZE_693: usize = 2;
+const IN_693: usize = 2;
+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_690], ExecError> {
+) -> Result<[G; OUT_693], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58449,14 +57892,14 @@ fn aiur_fn_690(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_690] = [__v_8];
-            record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_693] = [__v_8];
+            record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_690] = [__v_8];
-            record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_693] = [__v_8];
+            record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -58469,25 +57912,25 @@ fn aiur_fn_690(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_690] = [__v_8];
-            record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_693] = [__v_8];
+            record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_3, __v_6]; 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_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_690] = [__v_9];
-                record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_693] = [__v_9];
+                record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_690] = [__v_9];
-                record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_693] = [__v_9];
+                record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -58504,15 +57947,15 @@ fn aiur_fn_690(
   })
 }
 
-const INPUT_SIZE_691: usize = 11;
-const IN_691: usize = 11;
-const OUT_691: usize = 1;
-fn aiur_fn_691(
-  inp: [G; IN_691],
+const INPUT_SIZE_694: usize = 11;
+const IN_694: usize = 11;
+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_691], ExecError> {
+) -> Result<[G; OUT_694], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58527,56 +57970,56 @@ fn aiur_fn_691(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_691] = [__v_3];
-        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_694] = [__v_3];
+        record.function_queries[694].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_691] = [__v_11];
-            record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_694] = [__v_11];
+            record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_691] = [__v_11];
-            record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_694] = [__v_11];
+            record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_691] = [__v_11];
-        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_694] = [__v_11];
+        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_691] = [__v_4];
-        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_694] = [__v_4];
+        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_691] = [__v_11];
-        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_694] = [__v_11];
+        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_691] = [__v_6];
-        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_694] = [__v_6];
+        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_691] = [__v_7];
-        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_694] = [__v_7];
+        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_691] = [__v_9];
-        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_694] = [__v_9];
+        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58586,15 +58029,15 @@ fn aiur_fn_691(
   })
 }
 
-const INPUT_SIZE_692: usize = 2;
-const IN_692: usize = 2;
-const OUT_692: usize = 1;
-fn aiur_fn_692(
-  inp: [G; IN_692],
+const INPUT_SIZE_695: usize = 2;
+const IN_695: usize = 2;
+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_692], ExecError> {
+) -> Result<[G; OUT_695], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58606,18 +58049,18 @@ fn aiur_fn_692(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_692] = [__v_6];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [__v_6];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_692] = [__v_6];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [__v_6];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -58632,67 +58075,67 @@ fn aiur_fn_692(
         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_691] = { let __args: [G; IN_691] = [__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[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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__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[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_19: G = __r_arr[0];
         let __v_20: G = (__v_18 - __v_19);
-        let __ret: [G; OUT_692] = [__v_20];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [__v_20];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_4, __v_1]; 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 = (__v_6 * __v_7);
-        let __ret: [G; OUT_692] = [__v_8];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [__v_8];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_4, __v_1]; 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 = (__v_6 * __v_7);
-        let __ret: [G; OUT_692] = [__v_8];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [__v_8];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_4, __v_1]; 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 = (__v_6 * __v_7);
-        let __ret: [G; OUT_692] = [__v_8];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [__v_8];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_5, __v_1]; 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_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_692] = [__v_10];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [__v_10];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_692] = [__v_6];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [__v_6];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_5, __v_1]; 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_692] = [__v_6];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [__v_6];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58702,34 +58145,34 @@ fn aiur_fn_692(
   })
 }
 
-const INPUT_SIZE_693: usize = 3;
-const IN_693: usize = 3;
-const OUT_693: usize = 0;
-fn aiur_fn_693(
-  inp: [G; IN_693],
+const INPUT_SIZE_696: usize = 3;
+const IN_696: usize = 3;
+const OUT_696: usize = 0;
+fn aiur_fn_696(
+  inp: [G; IN_696],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_693], ExecError> {
+) -> Result<[G; OUT_696], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_693] = [];
-        record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_696] = [];
+        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_1, __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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_1, __v_2]; 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_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_693] = [];
-        record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_696] = [];
+        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58739,15 +58182,15 @@ fn aiur_fn_693(
   })
 }
 
-const INPUT_SIZE_694: usize = 2;
-const IN_694: usize = 2;
-const OUT_694: usize = 0;
-fn aiur_fn_694(
-  inp: [G; IN_694],
+const INPUT_SIZE_697: usize = 2;
+const IN_697: usize = 2;
+const OUT_697: usize = 0;
+fn aiur_fn_697(
+  inp: [G; IN_697],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_694], ExecError> {
+) -> Result<[G; OUT_697], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58757,28 +58200,28 @@ fn aiur_fn_694(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_694] = [];
-        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_697] = [];
+        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_3, __v_1]; 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 __ret: [G; OUT_694] = [];
-        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_3, __v_1]; 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 __ret: [G; OUT_697] = [];
+        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_4, __v_1]; 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 __ret: [G; OUT_694] = [];
-        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_4, __v_1]; 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 __ret: [G; OUT_697] = [];
+        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_4, __v_1]; 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 __ret: [G; OUT_694] = [];
-        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_4, __v_1]; 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 __ret: [G; OUT_697] = [];
+        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
@@ -58787,8 +58230,8 @@ fn aiur_fn_694(
         if (__v_5 != __v_6) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64() });
         }
-        let __ret: [G; OUT_694] = [];
-        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_697] = [];
+        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58798,15 +58241,15 @@ fn aiur_fn_694(
   })
 }
 
-const INPUT_SIZE_695: usize = 2;
-const IN_695: usize = 2;
-const OUT_695: usize = 0;
-fn aiur_fn_695(
-  inp: [G; IN_695],
+const INPUT_SIZE_698: usize = 2;
+const IN_698: usize = 2;
+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_695], ExecError> {
+) -> 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];
@@ -58816,15 +58259,15 @@ fn aiur_fn_695(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_695] = [];
-        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_698] = [];
+        record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_4, __v_1]; 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 __ret: [G; OUT_695] = [];
-        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_4, __v_1]; 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_698] = [];
+        record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58834,15 +58277,15 @@ fn aiur_fn_695(
   })
 }
 
-const INPUT_SIZE_696: usize = 4;
-const IN_696: usize = 4;
-const OUT_696: usize = 0;
-fn aiur_fn_696(
-  inp: [G; IN_696],
+const INPUT_SIZE_699: usize = 4;
+const IN_699: usize = 4;
+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_696], ExecError> {
+) -> 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];
@@ -58860,18 +58303,18 @@ fn aiur_fn_696(
         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_696] = [];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_699] = [];
+        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_5, __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 __ret: [G; OUT_696] = [];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_5, __v_2]; 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 __ret: [G; OUT_699] = [];
+        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __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];
@@ -58885,62 +58328,62 @@ fn aiur_fn_696(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__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[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 __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__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[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 __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
         let __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_695] = { let __args: [G; IN_695] = [__v_6, __v_2]; 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 __ret: [G; OUT_696] = [];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_6, __v_2]; 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_699] = [];
+        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_6, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_696] = [];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_6, __v_1, __v_2, __v_3]; 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);
       },
       4u64 => {
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_5, __v_1, __v_2, __v_3]; 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 __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_1 + __v_8);
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_696] = [];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_6, __v_9, __v_2, __v_3]; 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);
       },
       5u64 => {
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_5, __v_1, __v_2, __v_3]; 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 __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_1 + __v_8);
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_696] = [];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_6, __v_9, __v_2, __v_3]; 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);
       },
       6u64 => {
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_6, __v_1, __v_2, __v_3]; 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 __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_1 + __v_8);
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_7, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_696] = [];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_7, __v_9, __v_2, __v_3]; 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);
       },
       7u64 => {
-        let __ret: [G; OUT_696] = [];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_699] = [];
+        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_7, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_696] = [];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_7, __v_1, __v_2, __v_3]; 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);
       },
       _ => {
@@ -58950,15 +58393,15 @@ fn aiur_fn_696(
   })
 }
 
-const INPUT_SIZE_697: usize = 12;
-const IN_697: usize = 12;
-const OUT_697: usize = 0;
-fn aiur_fn_697(
-  inp: [G; IN_697],
+const INPUT_SIZE_700: usize = 12;
+const IN_700: usize = 12;
+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_697], ExecError> {
+) -> Result<[G; OUT_700], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58972,58 +58415,58 @@ fn aiur_fn_697(
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
-    let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__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[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 __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__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[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 __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__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[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 __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__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[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_13: G = __r_arr[0];
     let __v_14: G = G::from_u64(0);
-    let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_13, __v_14, __v_12, __v_11]; 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 __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_13, __v_14, __v_12, __v_11]; 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)? } };
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3, __v_15, __v_12, __v_11]; 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 __ret: [G; OUT_697] = [];
-        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3, __v_15, __v_12, __v_11]; 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_700] = [];
+        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3, __v_15, __v_12, __v_11]; 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 __ret: [G; OUT_697] = [];
-        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3, __v_15, __v_12, __v_11]; 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_700] = [];
+        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3, __v_15, __v_12, __v_11]; 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 __ret: [G; OUT_697] = [];
-        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3, __v_15, __v_12, __v_11]; 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_700] = [];
+        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_7, __v_12, __v_11]; 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_697] = [];
-        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_7, __v_12, __v_11]; 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_700] = [];
+        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_697] = [];
-        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_700] = [];
+        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_698: usize = 3;
-const IN_698: usize = 3;
-const OUT_698: usize = 0;
-fn aiur_fn_698(
-  inp: [G; IN_698],
+const INPUT_SIZE_701: usize = 3;
+const IN_701: usize = 3;
+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_698], ExecError> {
+) -> Result<[G; OUT_701], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59036,18 +58479,18 @@ fn aiur_fn_698(
     let __v_7: G = __loaded[4];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_698] = [];
-        record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_701] = [];
+        record.function_queries[701].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_696] = { let __args: [G; IN_696] = [__v_6, __v_8, __v_1, __v_2]; 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 __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_7, __v_1, __v_2]; 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_698] = [];
-            record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_6, __v_8, __v_1, __v_2]; 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 __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_7, __v_1, __v_2]; 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_701] = [];
+            record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -59059,24 +58502,24 @@ fn aiur_fn_698(
   })
 }
 
-const INPUT_SIZE_699: usize = 2;
-const IN_699: usize = 2;
-const OUT_699: usize = 0;
-fn aiur_fn_699(
-  inp: [G; IN_699],
+const INPUT_SIZE_702: usize = 2;
+const IN_702: usize = 2;
+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_699], ExecError> {
+) -> 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 __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 __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_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_2, __v_1, __v_3]; 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 __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_2, __v_1, __v_3]; 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_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];
@@ -59092,35 +58535,35 @@ fn aiur_fn_699(
     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_196] = { let __args: [G; IN_196] = [__v_11]; 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_17: G = G::from_u64(0);
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+        let __v_18: G = __r_arr[0];
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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() });
+        if (__v_7 != __v_20) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
         }
-        let __v_21: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = G::from_u64(2);
+        if (__v_9 != __v_21) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_21.as_canonical_u64() });
+        }
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_11]; 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_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = G::from_u64(1);
+        if (__v_22 != __v_23) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
+        }
+        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_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_19, __v_24]; 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_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_699] = [];
-        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_702] = [];
+        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -59130,15 +58573,15 @@ fn aiur_fn_699(
   })
 }
 
-const INPUT_SIZE_700: usize = 14;
-const IN_700: usize = 14;
-const OUT_700: usize = 0;
-fn aiur_fn_700(
-  inp: [G; IN_700],
+const INPUT_SIZE_703: usize = 14;
+const IN_703: usize = 14;
+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_700], ExecError> {
+) -> Result<[G; OUT_703], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59154,83 +58597,83 @@ fn aiur_fn_700(
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
     let __v_13: G = inp[13];
-    let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__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[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 __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__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[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 __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__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[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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__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[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_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_441] = { let __args: [G; IN_441] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_14, __v_2, __v_12]; 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 __ret: [G; OUT_700] = [];
-        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_2, __v_12]; 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 __ret: [G; OUT_703] = [];
+        record.function_queries[703].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_441] = { let __args: [G; IN_441] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_14, __v_3, __v_12]; 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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_3, __v_12]; 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_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_442] = { let __args: [G; IN_442] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __ret: [G; OUT_700] = [];
-        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_3, __v_2, __v_21, __v_12, __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 __ret: [G; OUT_703] = [];
+        record.function_queries[703].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_441] = { let __args: [G; IN_441] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __v_19: G = G::from_u64(0);
-        let __v_20: G = G::from_u64(0);
+        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_3, __v_12]; 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_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_225] = { let __args: [G; IN_225] = [__v_18, __v_21]; 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_22: G = __r_arr[0];
-        let __v_23: G = G::from_u64(1);
-        if (__v_22 != __v_23) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
+        let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_3, __v_2, __v_21, __v_12, __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_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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_18, __v_24]; 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_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 __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_14, __v_3, __v_12]; 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_24: G = G::from_u64(1);
-        let __v_25: G = G::from_u64(1);
-        let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3, __v_2, __v_26, __v_12, __v_13]; 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 __ret: [G; OUT_700] = [];
-        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_703] = [];
+        record.function_queries[703].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_441] = { let __args: [G; IN_441] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_14, __v_3, __v_12]; 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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_3, __v_12]; 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)? } };
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_700] = [];
-            record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_703] = [];
+            record.function_queries[703].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_442] = { let __args: [G; IN_442] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __ret: [G; OUT_700] = [];
-            record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_3, __v_2, __v_21, __v_12, __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 __ret: [G; OUT_703] = [];
+            record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -59242,38 +58685,38 @@ fn aiur_fn_700(
         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_441] = { let __args: [G; IN_441] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; 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_700] = [];
-        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; 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_703] = [];
+        record.function_queries[703].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_441] = { let __args: [G; IN_441] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_11, __v_2, __v_3, __v_4, __v_7, __v_12, __v_13]; 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 __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_11, __v_12, __v_13]; 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 __ret: [G; OUT_700] = [];
-        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_11, __v_2, __v_3, __v_4, __v_7, __v_12, __v_13]; 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 __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_11, __v_12, __v_13]; 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_703] = [];
+        record.function_queries[703].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_441] = { let __args: [G; IN_441] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__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[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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__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[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 __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -59289,27 +58732,27 @@ fn aiur_fn_700(
         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_629] = { let __args: [G; IN_629] = [__v_22, __v_2, __v_23, __v_12, __v_13]; 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_488] = { let __args: [G; IN_488] = [__v_2, __v_5, __v_24, __v_6, __v_3, __v_21, __v_12]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_22, __v_2, __v_23, __v_12, __v_13]; 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 __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_2, __v_5, __v_24, __v_6, __v_3, __v_21, __v_12]; 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 __v_31: G = (__v_23 + __v_24);
             let __v_32: G = G::from_u64(1);
             let __v_33: G = G::from_u64(1);
             let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_22, __v_31, __v_34, __v_12, __v_13]; 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 __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_22, __v_31, __v_34, __v_12, __v_13]; 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_35: G = __r_arr[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 __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_5, __v_35, __v_38, __v_12, __v_13]; 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 __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_5, __v_35, __v_38, __v_12, __v_13]; 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_39: G = G::from_u64(1);
             let __v_40: G = G::from_u64(1);
             let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_5, __v_3, __v_41, __v_12, __v_13]; 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 __ret: [G; OUT_700] = [];
-            record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_2, __v_5, __v_3, __v_41, __v_12, __v_13]; 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)? } };
+            if (__v_5 != __v_23) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
+            }
+            let __ret: [G; OUT_703] = [];
+            record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -59321,12 +58764,12 @@ fn aiur_fn_700(
         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_441] = { let __args: [G; IN_441] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__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[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 __ret: [G; OUT_700] = [];
-        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__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[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 __ret: [G; OUT_703] = [];
+        record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -59336,15 +58779,15 @@ fn aiur_fn_700(
   })
 }
 
-const INPUT_SIZE_701: usize = 6;
-const IN_701: usize = 6;
-const OUT_701: usize = 0;
-fn aiur_fn_701(
-  inp: [G; IN_701],
+const INPUT_SIZE_704: usize = 6;
+const IN_704: usize = 6;
+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_701], ExecError> {
+) -> Result<[G; OUT_704], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59354,9 +58797,9 @@ fn aiur_fn_701(
     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_236] = { let __args: [G; IN_236] = []; 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 __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_126] = { let __args: [G; IN_126] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_6]; 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_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     if (__v_7 != __v_8) {
@@ -59367,9 +58810,9 @@ fn aiur_fn_701(
     break '__mc_0 [__v_9, __v_10];
   },
   1u64 => {
-    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = []; 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 __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_126] = { let __args: [G; IN_126] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_6]; 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_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     if (__v_7 != __v_8) {
@@ -59380,23 +58823,23 @@ fn aiur_fn_701(
     break '__mc_0 [__v_9, __v_10];
   },
   2u64 => {
-    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 __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_4, __v_5]; 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 __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_126] = { let __args: [G; IN_126] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_6]; 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_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_699] = { let __args: [G; IN_699] = [__v_4, __v_5]; 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 __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_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 __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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_6]; 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_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     if (__v_7 != __v_8) {
@@ -59417,27 +58860,27 @@ fn aiur_fn_701(
       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_702] = { let __args: [G; IN_702] = [__v_3, __v_7, __v_8]; 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 __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } };
     let __v_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_701] = [];
-    record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_704] = [];
+    record.function_queries[704].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 = 1;
-fn aiur_fn_702(
-  inp: [G; IN_702],
+const INPUT_SIZE_705: usize = 3;
+const IN_705: usize = 3;
+const OUT_705: usize = 1;
+fn aiur_fn_705(
+  inp: [G; IN_705],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_702], ExecError> {
+) -> Result<[G; OUT_705], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59446,8 +58889,8 @@ fn aiur_fn_702(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_702] = [__v_4];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__v_4];
+        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -59460,16 +58903,16 @@ fn aiur_fn_702(
           5u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_2 + __v_8);
-            let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_6, __v_1, __v_9]; 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 __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_702] = [__v_10];
-            record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_705] = [__v_10];
+            record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_702] = [__v_8];
-            record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_705] = [__v_8];
+            record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -59478,37 +58921,37 @@ fn aiur_fn_702(
   })
 }
 
-const INPUT_SIZE_703: usize = 3;
-const IN_703: usize = 3;
-const OUT_703: usize = 0;
-fn aiur_fn_703(
-  inp: [G; IN_703],
+const INPUT_SIZE_706: usize = 3;
+const IN_706: usize = 3;
+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_703], ExecError> {
+) -> 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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_1, __v_2]; 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_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_1, __v_2, __v_3]; 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_703] = [];
-    record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_0, __v_1, __v_2, __v_3]; 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_706] = [];
+    record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_704: usize = 4;
-const IN_704: usize = 4;
-const OUT_704: usize = 0;
-fn aiur_fn_704(
-  inp: [G; IN_704],
+const INPUT_SIZE_707: usize = 4;
+const IN_707: usize = 4;
+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_704], ExecError> {
+) -> Result<[G; OUT_707], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59520,8 +58963,8 @@ fn aiur_fn_704(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_704] = [];
-        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_707] = [];
+        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -59537,12 +58980,12 @@ fn aiur_fn_704(
         let __v_15: G = __loaded[8];
         let __v_16: G = __loaded[9];
         let __v_17: G = __loaded[10];
-        let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__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[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 __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__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[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 __v_18: G = G::from_u64(1);
         let __v_19: G = (__v_3 + __v_18);
-        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_6, __v_1, __v_2, __v_19]; 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_704] = [];
-        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_6, __v_1, __v_2, __v_19]; 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);
       },
       _ => {
@@ -59552,35 +58995,35 @@ fn aiur_fn_704(
   })
 }
 
-const INPUT_SIZE_705: usize = 1;
-const IN_705: usize = 1;
-const OUT_705: usize = 3;
-fn aiur_fn_705(
-  inp: [G; IN_705],
+const INPUT_SIZE_708: usize = 1;
+const IN_708: usize = 1;
+const OUT_708: usize = 3;
+fn aiur_fn_708(
+  inp: [G; IN_708],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_705], ExecError> {
+) -> Result<[G; OUT_708], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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];
     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_705] = [__v_3, __v_4, __v_2];
-        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [__v_3, __v_4, __v_2];
+        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_705] = [__v_5, __v_3, __v_4];
-        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [__v_5, __v_3, __v_4];
+        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -59590,15 +59033,15 @@ fn aiur_fn_705(
   })
 }
 
-const INPUT_SIZE_706: usize = 2;
-const IN_706: usize = 2;
-const OUT_706: usize = 10;
-fn aiur_fn_706(
-  inp: [G; IN_706],
+const INPUT_SIZE_709: usize = 2;
+const IN_709: usize = 2;
+const OUT_709: usize = 10;
+fn aiur_fn_709(
+  inp: [G; IN_709],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_706], ExecError> {
+) -> Result<[G; OUT_709], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59606,12 +59049,12 @@ fn aiur_fn_706(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_706] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_709] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1];
+        record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -59622,23 +59065,23 @@ fn aiur_fn_706(
         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_706] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_709] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
+        record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_707: usize = 2;
-const IN_707: usize = 2;
-const OUT_707: usize = 3;
-fn aiur_fn_707(
-  inp: [G; IN_707],
+const INPUT_SIZE_710: usize = 2;
+const IN_710: usize = 2;
+const OUT_710: usize = 3;
+fn aiur_fn_710(
+  inp: [G; IN_710],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_707], ExecError> {
+) -> Result<[G; OUT_710], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59646,32 +59089,32 @@ fn aiur_fn_707(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_707] = [__v_2, __v_3, __v_1];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_710] = [__v_2, __v_3, __v_1];
+        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_1]; 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_707] = [__v_4, __v_2, __v_3];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_710] = [__v_4, __v_2, __v_3];
+        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_708: usize = 2;
-const IN_708: usize = 2;
-const OUT_708: usize = 3;
-fn aiur_fn_708(
-  inp: [G; IN_708],
+const INPUT_SIZE_711: usize = 2;
+const IN_711: usize = 2;
+const OUT_711: usize = 3;
+fn aiur_fn_711(
+  inp: [G; IN_711],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_708], ExecError> {
+) -> Result<[G; OUT_711], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59679,32 +59122,32 @@ fn aiur_fn_708(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_708] = [__v_2, __v_3, __v_1];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_711] = [__v_2, __v_3, __v_1];
+        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_1]; 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 __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 = G::from_u64(0);
-        let __ret: [G; OUT_708] = [__v_4, __v_2, __v_3];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_711] = [__v_4, __v_2, __v_3];
+        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_709: usize = 2;
-const IN_709: usize = 2;
-const OUT_709: usize = 3;
-fn aiur_fn_709(
-  inp: [G; IN_709],
+const INPUT_SIZE_712: usize = 2;
+const IN_712: usize = 2;
+const OUT_712: usize = 3;
+fn aiur_fn_712(
+  inp: [G; IN_712],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_709], ExecError> {
+) -> Result<[G; OUT_712], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59712,34 +59155,34 @@ fn aiur_fn_709(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_709] = [__v_2, __v_3, __v_1];
-        record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_712] = [__v_2, __v_3, __v_1];
+        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_1]; 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 __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];
         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_709] = [__v_4, __v_5, __v_3];
-            record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_712] = [__v_4, __v_5, __v_3];
+            record.function_queries[712].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_709] = [__v_4, __v_5, __v_3];
-            record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_712] = [__v_4, __v_5, __v_3];
+            record.function_queries[712].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_709] = [__v_4, __v_5, __v_3];
-            record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_712] = [__v_4, __v_5, __v_3];
+            record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -59751,15 +59194,15 @@ fn aiur_fn_709(
   })
 }
 
-const INPUT_SIZE_710: usize = 2;
-const IN_710: usize = 2;
-const OUT_710: usize = 3;
-fn aiur_fn_710(
-  inp: [G; IN_710],
+const INPUT_SIZE_713: usize = 2;
+const IN_713: usize = 2;
+const OUT_713: usize = 3;
+fn aiur_fn_713(
+  inp: [G; IN_713],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_710], ExecError> {
+) -> Result<[G; OUT_713], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59767,41 +59210,41 @@ fn aiur_fn_710(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_710] = [__v_2, __v_3, __v_1];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_713] = [__v_2, __v_3, __v_1];
+        record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_1]; 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 __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];
         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_710] = [__v_4, __v_5, __v_3];
-            record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_713] = [__v_4, __v_5, __v_3];
+            record.function_queries[713].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_710] = [__v_4, __v_5, __v_3];
-            record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_713] = [__v_4, __v_5, __v_3];
+            record.function_queries[713].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_710] = [__v_4, __v_5, __v_3];
-            record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_713] = [__v_4, __v_5, __v_3];
+            record.function_queries[713].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_710] = [__v_4, __v_5, __v_3];
-            record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_713] = [__v_4, __v_5, __v_3];
+            record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -59813,15 +59256,15 @@ fn aiur_fn_710(
   })
 }
 
-const INPUT_SIZE_711: usize = 9;
-const IN_711: usize = 9;
-const OUT_711: usize = 2;
-fn aiur_fn_711(
-  inp: [G; IN_711],
+const INPUT_SIZE_714: usize = 9;
+const IN_714: usize = 9;
+const OUT_714: usize = 2;
+fn aiur_fn_714(
+  inp: [G; IN_714],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_711], ExecError> {
+) -> Result<[G; OUT_714], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59839,12 +59282,12 @@ fn aiur_fn_711(
         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_711] = [__v_12, __v_0];
-        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_714] = [__v_12, __v_0];
+        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -59863,7 +59306,7 @@ fn aiur_fn_711(
         let __v_25: G = __r_arr[15];
         let __v_26: G = __r_arr[16];
         let __v_27: G = __r_arr[17];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -59872,28 +59315,28 @@ fn aiur_fn_711(
         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_711] = { let __args: [G; IN_711] = [__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[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 __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__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[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_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_711] = [__v_39, __v_37];
-        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_714] = [__v_39, __v_37];
+        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_712: usize = 2;
-const IN_712: usize = 2;
-const OUT_712: usize = 3;
-fn aiur_fn_712(
-  inp: [G; IN_712],
+const INPUT_SIZE_715: usize = 2;
+const IN_715: usize = 2;
+const OUT_715: usize = 3;
+fn aiur_fn_715(
+  inp: [G; IN_715],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_712], ExecError> {
+) -> Result<[G; OUT_715], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59901,12 +59344,12 @@ fn aiur_fn_712(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_712] = [__v_2, __v_3, __v_1];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_715] = [__v_2, __v_3, __v_1];
+        record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -59916,30 +59359,30 @@ fn aiur_fn_712(
         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_711] = { let __args: [G; IN_711] = [__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[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 __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__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[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 __v_12: G = __r_arr[1];
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_712] = [__v_13, __v_11, __v_12];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_715] = [__v_13, __v_11, __v_12];
+        record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_713: usize = 1;
-const IN_713: usize = 1;
-const OUT_713: usize = 41;
-fn aiur_fn_713(
-  inp: [G; IN_713],
+const INPUT_SIZE_716: usize = 1;
+const IN_716: usize = 1;
+const OUT_716: usize = 41;
+fn aiur_fn_716(
+  inp: [G; IN_716],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_713], ExecError> {
+) -> Result<[G; OUT_716], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; 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 __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];
@@ -59958,11 +59401,11 @@ fn aiur_fn_713(
     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_708] = { let __args: [G; IN_708] = [__v_10, __v_9]; 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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_10, __v_9]; 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_18: G = __r_arr[0];
     let __v_19: G = __r_arr[1];
     let __v_20: G = __r_arr[2];
-    let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
     let __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -59973,7 +59416,7 @@ fn aiur_fn_713(
     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_706] = { let __args: [G; IN_706] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
     let __v_31: G = __r_arr[0];
     let __v_32: G = __r_arr[1];
     let __v_33: G = __r_arr[2];
@@ -59984,7 +59427,7 @@ fn aiur_fn_713(
     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_706] = { let __args: [G; IN_706] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
     let __v_41: G = __r_arr[0];
     let __v_42: G = __r_arr[1];
     let __v_43: G = __r_arr[2];
@@ -59995,7 +59438,7 @@ fn aiur_fn_713(
     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_706] = { let __args: [G; IN_706] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
     let __v_51: G = __r_arr[0];
     let __v_52: G = __r_arr[1];
     let __v_53: G = __r_arr[2];
@@ -60006,28 +59449,28 @@ fn aiur_fn_713(
     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_707] = { let __args: [G; IN_707] = [__v_15, __v_60]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_15, __v_60]; 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 __v_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
     let __v_63: G = __r_arr[2];
-    let __ret: [G; OUT_713] = [__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[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_716] = [__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[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_714: usize = 1;
-const IN_714: usize = 1;
-const OUT_714: usize = 49;
-fn aiur_fn_714(
-  inp: [G; IN_714],
+const INPUT_SIZE_717: usize = 1;
+const IN_717: usize = 1;
+const OUT_717: usize = 49;
+fn aiur_fn_717(
+  inp: [G; IN_717],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_714], ExecError> {
+) -> Result<[G; OUT_717], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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];
@@ -60037,7 +59480,7 @@ fn aiur_fn_714(
     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_713] = { let __args: [G; IN_713] = [__v_9]; 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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_9]; 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -60079,21 +59522,21 @@ fn aiur_fn_714(
     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_714] = [__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[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_717] = [__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[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_715: usize = 9;
-const IN_715: usize = 9;
-const OUT_715: usize = 2;
-fn aiur_fn_715(
-  inp: [G; IN_715],
+const INPUT_SIZE_718: usize = 9;
+const IN_718: usize = 9;
+const OUT_718: usize = 2;
+fn aiur_fn_718(
+  inp: [G; IN_718],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_715], ExecError> {
+) -> Result<[G; OUT_718], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60111,12 +59554,12 @@ fn aiur_fn_715(
         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_715] = [__v_12, __v_0];
-        record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_718] = [__v_12, __v_0];
+        record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; 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 __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_0]; 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -60166,7 +59609,7 @@ fn aiur_fn_715(
         let __v_56: G = __r_arr[46];
         let __v_57: G = __r_arr[47];
         let __v_58: G = __r_arr[48];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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_59: G = __r_arr[0];
         let __v_60: G = __r_arr[1];
         let __v_61: G = __r_arr[2];
@@ -60175,28 +59618,28 @@ fn aiur_fn_715(
         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_715] = { let __args: [G; IN_715] = [__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[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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__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[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__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_715] = [__v_70, __v_68];
-        record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_718] = [__v_70, __v_68];
+        record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_716: usize = 2;
-const IN_716: usize = 2;
-const OUT_716: usize = 3;
-fn aiur_fn_716(
-  inp: [G; IN_716],
+const INPUT_SIZE_719: usize = 2;
+const IN_719: usize = 2;
+const OUT_719: usize = 3;
+fn aiur_fn_719(
+  inp: [G; IN_719],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_716], ExecError> {
+) -> Result<[G; OUT_719], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60204,12 +59647,12 @@ fn aiur_fn_716(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_716] = [__v_2, __v_3, __v_1];
-        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_719] = [__v_2, __v_3, __v_1];
+        record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -60219,33 +59662,33 @@ fn aiur_fn_716(
         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_715] = { let __args: [G; IN_715] = [__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[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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__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[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __v_12: G = __r_arr[1];
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_716] = [__v_13, __v_11, __v_12];
-        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_719] = [__v_13, __v_11, __v_12];
+        record.function_queries[719].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 = 55;
-fn aiur_fn_717(
-  inp: [G; IN_717],
+const INPUT_SIZE_720: usize = 1;
+const IN_720: usize = 1;
+const OUT_720: usize = 55;
+fn aiur_fn_720(
+  inp: [G; IN_720],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_717], ExecError> {
+) -> Result<[G; OUT_720], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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 __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -60275,15 +59718,15 @@ fn aiur_fn_717(
     let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_13, __v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60294,26 +59737,26 @@ fn aiur_fn_717(
         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_707] = { let __args: [G; IN_707] = [__v_15, __v_43]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_15, __v_43]; 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 __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_707] = { let __args: [G; IN_707] = [__v_16, __v_46]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_16, __v_46]; 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 __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_717] = [__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[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_720] = [__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[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_12, __v_11]; 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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -60324,7 +59767,7 @@ fn aiur_fn_717(
         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_706] = { let __args: [G; IN_706] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_41: G = __r_arr[0];
         let __v_42: G = __r_arr[1];
         let __v_43: G = __r_arr[2];
@@ -60335,7 +59778,7 @@ fn aiur_fn_717(
         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_706] = { let __args: [G; IN_706] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_51: G = __r_arr[0];
         let __v_52: G = __r_arr[1];
         let __v_53: G = __r_arr[2];
@@ -60346,30 +59789,30 @@ fn aiur_fn_717(
         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_707] = { let __args: [G; IN_707] = [__v_16, __v_60]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_16, __v_60]; 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 __v_61: G = __r_arr[0];
         let __v_62: G = __r_arr[1];
         let __v_63: G = __r_arr[2];
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_17, __v_63]; 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 __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_17, __v_63]; 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_64: G = __r_arr[0];
         let __v_65: G = __r_arr[1];
         let __v_66: G = __r_arr[2];
         let __v_67: G = G::from_u64(1);
         let __v_68: G = G::from_u64(0);
-        let __ret: [G; OUT_717] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66];
-        record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_720] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66];
+        record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_12, __v_11]; 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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_13, __v_30]; 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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_13, __v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60380,7 +59823,7 @@ fn aiur_fn_717(
         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_706] = { let __args: [G; IN_706] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -60391,7 +59834,7 @@ fn aiur_fn_717(
         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_706] = { let __args: [G; IN_706] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_54: G = __r_arr[0];
         let __v_55: G = __r_arr[1];
         let __v_56: G = __r_arr[2];
@@ -60402,7 +59845,7 @@ fn aiur_fn_717(
         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_706] = { let __args: [G; IN_706] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_64: G = __r_arr[0];
         let __v_65: G = __r_arr[1];
         let __v_66: G = __r_arr[2];
@@ -60413,7 +59856,7 @@ fn aiur_fn_717(
         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_706] = { let __args: [G; IN_706] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_74: G = __r_arr[0];
         let __v_75: G = __r_arr[1];
         let __v_76: G = __r_arr[2];
@@ -60424,17 +59867,17 @@ fn aiur_fn_717(
         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_707] = { let __args: [G; IN_707] = [__v_19, __v_83]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_19, __v_83]; 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 __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_712] = { let __args: [G; IN_712] = [__v_20, __v_86]; 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 __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_20, __v_86]; 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_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_717] = [__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[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_720] = [__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[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -60444,18 +59887,18 @@ fn aiur_fn_717(
   })
 }
 
-const INPUT_SIZE_718: usize = 1;
-const IN_718: usize = 1;
-const OUT_718: usize = 63;
-fn aiur_fn_718(
-  inp: [G; IN_718],
+const INPUT_SIZE_721: usize = 1;
+const IN_721: usize = 1;
+const OUT_721: usize = 63;
+fn aiur_fn_721(
+  inp: [G; IN_721],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_718], ExecError> {
+) -> Result<[G; OUT_721], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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];
@@ -60465,7 +59908,7 @@ fn aiur_fn_718(
     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_717] = { let __args: [G; IN_717] = [__v_9]; 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 __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_9]; 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -60521,21 +59964,21 @@ fn aiur_fn_718(
     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_718] = [__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[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_721] = [__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[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_719: usize = 9;
-const IN_719: usize = 9;
-const OUT_719: usize = 2;
-fn aiur_fn_719(
-  inp: [G; IN_719],
+const INPUT_SIZE_722: usize = 9;
+const IN_722: usize = 9;
+const OUT_722: usize = 2;
+fn aiur_fn_722(
+  inp: [G; IN_722],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_719], ExecError> {
+) -> Result<[G; OUT_722], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60553,12 +59996,12 @@ fn aiur_fn_719(
         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_719] = [__v_12, __v_0];
-        record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_722] = [__v_12, __v_0];
+        record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__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 __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_0]; 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -60622,7 +60065,7 @@ fn aiur_fn_719(
         let __v_70: G = __r_arr[60];
         let __v_71: G = __r_arr[61];
         let __v_72: G = __r_arr[62];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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_73: G = __r_arr[0];
         let __v_74: G = __r_arr[1];
         let __v_75: G = __r_arr[2];
@@ -60631,34 +60074,34 @@ fn aiur_fn_719(
         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_719] = { let __args: [G; IN_719] = [__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[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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__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[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_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_719] = [__v_84, __v_82];
-        record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_722] = [__v_84, __v_82];
+        record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_720: usize = 1;
-const IN_720: usize = 1;
-const OUT_720: usize = 55;
-fn aiur_fn_720(
-  inp: [G; IN_720],
+const INPUT_SIZE_723: usize = 1;
+const IN_723: usize = 1;
+const OUT_723: usize = 55;
+fn aiur_fn_723(
+  inp: [G; IN_723],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_720], ExecError> {
+) -> Result<[G; OUT_723], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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 __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -60688,15 +60131,15 @@ fn aiur_fn_720(
     let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_13, __v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60707,30 +60150,30 @@ fn aiur_fn_720(
         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_707] = { let __args: [G; IN_707] = [__v_15, __v_43]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_15, __v_43]; 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 __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_707] = { let __args: [G; IN_707] = [__v_16, __v_46]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_16, __v_46]; 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 __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_720] = [__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[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [__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[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_12, __v_11]; 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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_13, __v_30]; 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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_13, __v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60741,7 +60184,7 @@ fn aiur_fn_720(
         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_706] = { let __args: [G; IN_706] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -60752,7 +60195,7 @@ fn aiur_fn_720(
         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_706] = { let __args: [G; IN_706] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_54: G = __r_arr[0];
         let __v_55: G = __r_arr[1];
         let __v_56: G = __r_arr[2];
@@ -60763,7 +60206,7 @@ fn aiur_fn_720(
         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_706] = { let __args: [G; IN_706] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_64: G = __r_arr[0];
         let __v_65: G = __r_arr[1];
         let __v_66: G = __r_arr[2];
@@ -60774,7 +60217,7 @@ fn aiur_fn_720(
         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_706] = { let __args: [G; IN_706] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_74: G = __r_arr[0];
         let __v_75: G = __r_arr[1];
         let __v_76: G = __r_arr[2];
@@ -60785,25 +60228,25 @@ fn aiur_fn_720(
         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_707] = { let __args: [G; IN_707] = [__v_19, __v_83]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_19, __v_83]; 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 __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_712] = { let __args: [G; IN_712] = [__v_20, __v_86]; 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 __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_20, __v_86]; 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_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_720] = [__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[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [__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[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_12, __v_11]; 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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -60814,22 +60257,22 @@ fn aiur_fn_720(
         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_707] = { let __args: [G; IN_707] = [__v_14, __v_40]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_14, __v_40]; 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 __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_720] = [__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[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [__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[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_12, __v_11]; 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 __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -60840,18 +60283,18 @@ fn aiur_fn_720(
         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_707] = { let __args: [G; IN_707] = [__v_14, __v_40]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_14, __v_40]; 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 __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_720] = [__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[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [__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[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -60862,7 +60305,7 @@ fn aiur_fn_720(
         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_706] = { let __args: [G; IN_706] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
         let __v_39: G = __r_arr[1];
         let __v_40: G = __r_arr[2];
@@ -60873,18 +60316,18 @@ fn aiur_fn_720(
         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_707] = { let __args: [G; IN_707] = [__v_14, __v_47]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_14, __v_47]; 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 __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_720] = [__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[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [__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[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -60895,18 +60338,18 @@ fn aiur_fn_720(
         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_707] = { let __args: [G; IN_707] = [__v_13, __v_37]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_13, __v_37]; 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 __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_720] = [__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[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [__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[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -60917,18 +60360,18 @@ fn aiur_fn_720(
         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_707] = { let __args: [G; IN_707] = [__v_13, __v_37]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_13, __v_37]; 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 __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_720] = [__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[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [__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[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -60939,14 +60382,14 @@ fn aiur_fn_720(
         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_707] = { let __args: [G; IN_707] = [__v_13, __v_37]; 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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_13, __v_37]; 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 __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_720] = [__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[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [__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[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
@@ -60958,7 +60401,7 @@ fn aiur_fn_720(
     break '__mc_0 [__v_30, __v_11];
   },
   1u64 => {
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_11]; 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !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_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
     let __v_30: G = __r_arr[2];
@@ -60968,7 +60411,7 @@ fn aiur_fn_720(
     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_719] = { let __args: [G; IN_719] = [__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[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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__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[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_37: G = __r_arr[0];
     let __v_38: G = __r_arr[1];
     break '__mc_0 [__v_37, __v_38];
@@ -60982,8 +60425,8 @@ fn aiur_fn_720(
         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_720] = [__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[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [__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[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -60993,18 +60436,18 @@ fn aiur_fn_720(
   })
 }
 
-const INPUT_SIZE_721: usize = 1;
-const IN_721: usize = 1;
-const OUT_721: usize = 57;
-fn aiur_fn_721(
-  inp: [G; IN_721],
+const INPUT_SIZE_724: usize = 1;
+const IN_724: usize = 1;
+const OUT_724: usize = 57;
+fn aiur_fn_724(
+  inp: [G; IN_724],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_721], ExecError> {
+) -> Result<[G; OUT_724], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -61021,55 +60464,55 @@ fn aiur_fn_721(
     }
     match __v_2.as_canonical_u64() {
       3u64 => {
-        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 __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10]; 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_13]; 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_15]; 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 __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_721] = [__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[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_724] = [__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[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        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 __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10]; 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_13]; 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 __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_721] = [__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[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_724] = [__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[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        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 __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10]; 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_13]; 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 __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_721] = [__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[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_724] = [__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[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        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 __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10]; 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13]; 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 __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13]; 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         let __v_16: G = __r_arr[2];
@@ -61126,21 +60569,21 @@ fn aiur_fn_721(
         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_721] = [__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[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_724] = [__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[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        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 __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10]; 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_13]; 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_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_721] = [__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[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_724] = [__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[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61150,15 +60593,15 @@ fn aiur_fn_721(
   })
 }
 
-const INPUT_SIZE_722: usize = 32;
-const IN_722: usize = 32;
-const OUT_722: usize = 56;
-fn aiur_fn_722(
-  inp: [G; IN_722],
+const INPUT_SIZE_725: usize = 32;
+const IN_725: usize = 32;
+const OUT_725: usize = 56;
+fn aiur_fn_725(
+  inp: [G; IN_725],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_722], ExecError> {
+) -> Result<[G; OUT_725], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61199,8 +60642,8 @@ fn aiur_fn_722(
     let __v_35: G = G::from_u64(0);
     let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_35, __v_33, __v_34]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_36, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_36]; 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 __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_36]; 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_37: G = __r_arr[0];
     let __v_38: G = __r_arr[1];
     let __v_39: G = __r_arr[2];
@@ -61273,21 +60716,21 @@ fn aiur_fn_722(
     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_722] = [__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[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_725] = [__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[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_723: usize = 1;
-const IN_723: usize = 1;
-const OUT_723: usize = 1;
-fn aiur_fn_723(
-  inp: [G; IN_723],
+const INPUT_SIZE_726: usize = 1;
+const IN_726: usize = 1;
+const OUT_726: usize = 1;
+fn aiur_fn_726(
+  inp: [G; IN_726],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_723], ExecError> {
+) -> Result<[G; OUT_726], 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 };
@@ -61312,44 +60755,44 @@ fn aiur_fn_723(
     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_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
     let __v_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_22]; 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_23: G = __r_arr[0];
-    let __ret: [G; OUT_723] = [__v_23];
-    record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_726] = [__v_23];
+    record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_724: usize = 1;
-const IN_724: usize = 1;
-const OUT_724: usize = 1;
-fn aiur_fn_724(
-  inp: [G; IN_724],
+const INPUT_SIZE_727: usize = 1;
+const IN_727: usize = 1;
+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_724], ExecError> {
+) -> Result<[G; OUT_727], 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_724] = [__v_1];
-        record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_727] = [__v_1];
+        record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_724] = [__v_1];
-        record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_727] = [__v_1];
+        record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_724] = [__v_1];
-        record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_727] = [__v_1];
+        record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61359,35 +60802,35 @@ fn aiur_fn_724(
   })
 }
 
-const INPUT_SIZE_725: usize = 3;
-const IN_725: usize = 3;
-const OUT_725: usize = 0;
-fn aiur_fn_725(
-  inp: [G; IN_725],
+const INPUT_SIZE_728: usize = 3;
+const IN_728: usize = 3;
+const OUT_728: usize = 0;
+fn aiur_fn_728(
+  inp: [G; IN_728],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_725], ExecError> {
+) -> 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];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_725] = [];
-        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_728] = [];
+        record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_0]; 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 __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_0]; 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; 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 __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_2]; 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_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_725] = [];
-        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_728] = [];
+        record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61397,35 +60840,35 @@ fn aiur_fn_725(
   })
 }
 
-const INPUT_SIZE_726: usize = 3;
-const IN_726: usize = 3;
-const OUT_726: usize = 0;
-fn aiur_fn_726(
-  inp: [G; IN_726],
+const INPUT_SIZE_729: usize = 3;
+const IN_729: usize = 3;
+const OUT_729: usize = 0;
+fn aiur_fn_729(
+  inp: [G; IN_729],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_726], ExecError> {
+) -> Result<[G; OUT_729], ExecError> {
   stacker::maybe_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_726] = [];
-        record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_729] = [];
+        record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_2]; 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_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_726] = [];
-        record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_729] = [];
+        record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61435,31 +60878,31 @@ fn aiur_fn_726(
   })
 }
 
-const INPUT_SIZE_727: usize = 3;
-const IN_727: usize = 3;
-const OUT_727: usize = 0;
-fn aiur_fn_727(
-  inp: [G; IN_727],
+const INPUT_SIZE_730: usize = 3;
+const IN_730: usize = 3;
+const OUT_730: usize = 0;
+fn aiur_fn_730(
+  inp: [G; IN_730],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_727], ExecError> {
+) -> Result<[G; OUT_730], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_727] = [];
-        record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_730] = [];
+        record.function_queries[730].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_727] = [];
-        record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_730] = [];
+        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61469,15 +60912,15 @@ fn aiur_fn_727(
   })
 }
 
-const INPUT_SIZE_728: usize = 17;
-const IN_728: usize = 17;
-const OUT_728: usize = 0;
-fn aiur_fn_728(
-  inp: [G; IN_728],
+const INPUT_SIZE_731: usize = 17;
+const IN_731: usize = 17;
+const OUT_731: usize = 0;
+fn aiur_fn_731(
+  inp: [G; IN_731],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_728], ExecError> {
+) -> Result<[G; OUT_731], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61498,8 +60941,8 @@ fn aiur_fn_728(
     let __v_16: G = inp[16];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_728] = [];
-        record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_731] = [];
+        record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -61527,8 +60970,8 @@ fn aiur_fn_728(
         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_728] = [];
-        record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_731] = [];
+        record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61538,23 +60981,23 @@ fn aiur_fn_728(
   })
 }
 
-const INPUT_SIZE_729: usize = 3;
-const IN_729: usize = 3;
-const OUT_729: usize = 0;
-fn aiur_fn_729(
-  inp: [G; IN_729],
+const INPUT_SIZE_732: usize = 3;
+const IN_732: usize = 3;
+const OUT_732: usize = 0;
+fn aiur_fn_732(
+  inp: [G; IN_732],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_729], ExecError> {
+) -> Result<[G; OUT_732], ExecError> {
   stacker::maybe_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_729] = [];
-        record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_732] = [];
+        record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -61720,8 +61163,8 @@ fn aiur_fn_729(
         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_729] = [];
-        record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_732] = [];
+        record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61731,27 +61174,27 @@ fn aiur_fn_729(
   })
 }
 
-const INPUT_SIZE_730: usize = 3;
-const IN_730: usize = 3;
-const OUT_730: usize = 0;
-fn aiur_fn_730(
-  inp: [G; IN_730],
+const INPUT_SIZE_733: usize = 3;
+const IN_733: usize = 3;
+const OUT_733: usize = 0;
+fn aiur_fn_733(
+  inp: [G; IN_733],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_730], ExecError> {
+) -> 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];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_730] = [];
-        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_733] = [];
+        record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_0]; 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 __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0]; 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_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];
@@ -61915,8 +61358,8 @@ fn aiur_fn_730(
         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_730] = [];
-        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_733] = [];
+        record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61926,15 +61369,15 @@ fn aiur_fn_730(
   })
 }
 
-const INPUT_SIZE_731: usize = 2;
-const IN_731: usize = 2;
-const OUT_731: usize = 0;
-fn aiur_fn_731(
-  inp: [G; IN_731],
+const INPUT_SIZE_734: usize = 2;
+const IN_734: usize = 2;
+const OUT_734: usize = 0;
+fn aiur_fn_734(
+  inp: [G; IN_734],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_731], ExecError> {
+) -> Result<[G; OUT_734], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61974,8 +61417,8 @@ fn aiur_fn_731(
         let __v_31: G = __loaded[10];
         match __v_21.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_731] = [];
-            record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_734] = [];
+            record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -62002,6 +61445,8 @@ fn aiur_fn_731(
               _ => {
                 match __v_22.as_canonical_u64() {
                   _ => {
+                    let __v_32: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_30, __v_32, __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)? } };
                     if (__v_22 != __v_11) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
                     }
@@ -62026,11 +61471,9 @@ fn aiur_fn_731(
                     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_730] = { let __args: [G; IN_730] = [__v_30, __v_32, __v_19]; 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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_31, __v_20]; 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 __ret: [G; OUT_731] = [];
-                    record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_31, __v_20]; 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 __ret: [G; OUT_734] = [];
+                    record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -62049,29 +61492,29 @@ fn aiur_fn_731(
   })
 }
 
-const INPUT_SIZE_732: usize = 3;
-const IN_732: usize = 3;
-const OUT_732: usize = 0;
-fn aiur_fn_732(
-  inp: [G; IN_732],
+const INPUT_SIZE_735: usize = 3;
+const IN_735: usize = 3;
+const OUT_735: usize = 0;
+fn aiur_fn_735(
+  inp: [G; IN_735],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_732], ExecError> {
+) -> Result<[G; OUT_735], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_732] = [];
-        record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_735] = [];
+        record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_2]; 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 __ret: [G; OUT_732] = [];
-        record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_2]; 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 __ret: [G; OUT_735] = [];
+        record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62081,15 +61524,15 @@ fn aiur_fn_732(
   })
 }
 
-const INPUT_SIZE_733: usize = 49;
-const IN_733: usize = 49;
-const OUT_733: usize = 0;
-fn aiur_fn_733(
-  inp: [G; IN_733],
+const INPUT_SIZE_736: usize = 49;
+const IN_736: usize = 49;
+const OUT_736: usize = 0;
+fn aiur_fn_736(
+  inp: [G; IN_736],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_733], ExecError> {
+) -> Result<[G; OUT_736], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -62140,7 +61583,7 @@ fn aiur_fn_733(
     let __v_46: G = inp[46];
     let __v_47: G = inp[47];
     let __v_48: G = inp[48];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__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[780].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } else { aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_49: G = __r_arr[0];
     let __v_50: G = __r_arr[1];
     let __v_51: G = __r_arr[2];
@@ -62179,14 +61622,14 @@ fn aiur_fn_733(
       _ => {
         match __v_49.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_49, __v_9, __v_10]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_82, __v_47, __v_48]; 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 __ret: [G; OUT_733] = [];
-            record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_49, __v_9, __v_10]; 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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_82, __v_47, __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 __ret: [G; OUT_736] = [];
+            record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -62195,15 +61638,15 @@ fn aiur_fn_733(
   })
 }
 
-const INPUT_SIZE_734: usize = 2;
-const IN_734: usize = 2;
-const OUT_734: usize = 0;
-fn aiur_fn_734(
-  inp: [G; IN_734],
+const INPUT_SIZE_737: usize = 2;
+const IN_737: usize = 2;
+const OUT_737: usize = 0;
+fn aiur_fn_737(
+  inp: [G; IN_737],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_734], ExecError> {
+) -> Result<[G; OUT_737], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -62260,15 +61703,15 @@ fn aiur_fn_734(
     let __v_51: G = __loaded[49];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_734] = [];
-        record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_737] = [];
+        record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__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[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 __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_51]; 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 __ret: [G; OUT_734] = [];
-        record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__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[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 __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0, __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 __ret: [G; OUT_737] = [];
+        record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62278,29 +61721,29 @@ fn aiur_fn_734(
   })
 }
 
-const INPUT_SIZE_735: usize = 3;
-const IN_735: usize = 3;
-const OUT_735: usize = 0;
-fn aiur_fn_735(
-  inp: [G; IN_735],
+const INPUT_SIZE_738: usize = 3;
+const IN_738: usize = 3;
+const OUT_738: usize = 0;
+fn aiur_fn_738(
+  inp: [G; IN_738],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_735], ExecError> {
+) -> Result<[G; OUT_738], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_735] = [];
-        record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_738] = [];
+        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_2]; 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 __ret: [G; OUT_735] = [];
-        record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0, __v_2]; 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 __ret: [G; OUT_738] = [];
+        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62310,15 +61753,15 @@ fn aiur_fn_735(
   })
 }
 
-const INPUT_SIZE_736: usize = 99;
-const IN_736: usize = 99;
-const OUT_736: usize = 0;
-fn aiur_fn_736(
-  inp: [G; IN_736],
+const INPUT_SIZE_739: usize = 99;
+const IN_739: usize = 99;
+const OUT_739: usize = 0;
+fn aiur_fn_739(
+  inp: [G; IN_739],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_736], ExecError> {
+) -> Result<[G; OUT_739], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -62425,13 +61868,13 @@ fn aiur_fn_736(
           0u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_1, __v_46, __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 __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_2, __v_48, __v_49]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_11, __v_59, __v_60]; 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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_12, __v_61, __v_62]; 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 __ret: [G; OUT_736] = [];
-                record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_1, __v_46, __v_47]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_48, __v_49]; 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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_11, __v_59, __v_60]; 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 __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_12, __v_61, __v_62]; 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 __ret: [G; OUT_739] = [];
+                record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -62446,14 +61889,14 @@ fn aiur_fn_736(
           1u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_46, __v_47]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_26, __v_75, __v_76]; 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 __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_27, __v_77, __v_78]; 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 __ret: [G; OUT_736] = [];
-                record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_1, __v_46, __v_47]; 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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_26, __v_75, __v_76]; 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 __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_27, __v_77, __v_78]; 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 __ret: [G; OUT_739] = [];
+                record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -62468,17 +61911,17 @@ fn aiur_fn_736(
           2u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_46, __v_47]; 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 __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_2, __v_48, __v_49]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_43, __v_95, __v_96]; 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 __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_44, __v_97, __v_98]; 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 __ret: [G; OUT_736] = [];
-                record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_1, __v_46, __v_47]; 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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_2, __v_48, __v_49]; 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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_43, __v_95, __v_96]; 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 __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_44, __v_97, __v_98]; 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 __ret: [G; OUT_739] = [];
+                record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -62495,15 +61938,15 @@ fn aiur_fn_736(
   })
 }
 
-const INPUT_SIZE_737: usize = 2;
-const IN_737: usize = 2;
-const OUT_737: usize = 0;
-fn aiur_fn_737(
-  inp: [G; IN_737],
+const INPUT_SIZE_740: usize = 2;
+const IN_740: usize = 2;
+const OUT_740: usize = 0;
+fn aiur_fn_740(
+  inp: [G; IN_740],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_737], ExecError> {
+) -> Result<[G; OUT_740], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -62574,12 +62017,12 @@ fn aiur_fn_737(
     let __v_65: G = __loaded[63];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_737] = [];
-        record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_740] = [];
+        record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__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[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
         let __v_66: G = __r_arr[0];
         let __v_67: G = __r_arr[1];
         let __v_68: G = __r_arr[2];
@@ -62625,10 +62068,10 @@ fn aiur_fn_737(
         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_736] = { let __args: [G; IN_736] = [__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[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 __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0, __v_65]; 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 __ret: [G; OUT_737] = [];
-        record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__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[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 __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_65]; 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 __ret: [G; OUT_740] = [];
+        record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62638,91 +62081,91 @@ fn aiur_fn_737(
   })
 }
 
-const INPUT_SIZE_738: usize = 1;
-const IN_738: usize = 1;
-const OUT_738: usize = 1;
-fn aiur_fn_738(
-  inp: [G; IN_738],
+const INPUT_SIZE_741: usize = 1;
+const IN_741: usize = 1;
+const OUT_741: usize = 1;
+fn aiur_fn_741(
+  inp: [G; IN_741],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_738], ExecError> {
+) -> Result<[G; OUT_741], 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_43] = { let __args: [G; IN_43] = [__v_0, __v_3]; 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 __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = G::from_u64(0);
     let __v_6: G = G::from_u64(0);
     let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_7]; 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_8: G = __r_arr[0];
-    let __ret: [G; OUT_738] = [__v_8];
-    record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_741] = [__v_8];
+    record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_739: usize = 2;
-const IN_739: usize = 2;
-const OUT_739: usize = 1;
-fn aiur_fn_739(
-  inp: [G; IN_739],
+const INPUT_SIZE_742: usize = 2;
+const IN_742: usize = 2;
+const OUT_742: usize = 1;
+fn aiur_fn_742(
+  inp: [G; IN_742],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_739], ExecError> {
+) -> Result<[G; OUT_742], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = 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_43] = { let __args: [G; IN_43] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_5]; 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 __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = G::from_u64(0);
     let __v_8: G = G::from_u64(1);
     let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9]; 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_10: G = __r_arr[0];
-    let __ret: [G; OUT_739] = [__v_10];
-    record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_742] = [__v_10];
+    record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_740: usize = 1;
-const IN_740: usize = 1;
-const OUT_740: usize = 3;
-fn aiur_fn_740(
-  inp: [G; IN_740],
+const INPUT_SIZE_743: usize = 1;
+const IN_743: usize = 1;
+const OUT_743: usize = 3;
+fn aiur_fn_743(
+  inp: [G; IN_743],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_740], ExecError> {
+) -> Result<[G; OUT_743], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; 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 __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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
-        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_3]; 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_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_740] = [__v_5, __v_10, __v_4];
-        record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_743] = [__v_5, __v_10, __v_4];
+        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -62762,25 +62205,25 @@ fn aiur_fn_740(
         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_740] = [__v_35, __v_38, __v_2];
-        record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_743] = [__v_35, __v_38, __v_2];
+        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2]; 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 __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
         let __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_740] = { let __args: [G; IN_740] = [__v_5]; 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 __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
         let __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_739] = { let __args: [G; IN_739] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_3, __v_6]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_740] = [__v_9, __v_10, __v_8];
-        record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_743] = [__v_9, __v_10, __v_8];
+        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62790,15 +62233,15 @@ fn aiur_fn_740(
   })
 }
 
-const INPUT_SIZE_741: usize = 1;
-const IN_741: usize = 1;
-const OUT_741: usize = 1;
-fn aiur_fn_741(
-  inp: [G; IN_741],
+const INPUT_SIZE_744: usize = 1;
+const IN_744: usize = 1;
+const OUT_744: usize = 1;
+fn aiur_fn_744(
+  inp: [G; IN_744],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_741], ExecError> {
+) -> Result<[G; OUT_744], 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 };
@@ -62841,7 +62284,7 @@ fn aiur_fn_741(
     let __v_36: G = G::from_u64(1);
     let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_37]; 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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -62852,177 +62295,177 @@ fn aiur_fn_741(
     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_740] = { let __args: [G; IN_740] = [__v_47]; 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_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() });
+    let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
+    let __v_48: G = __r_arr[0];
+    let __v_49: G = __r_arr[1];
+    let __v_50: G = __r_arr[2];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; 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: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_51: G = __loaded[0];
+    let __v_52: G = __loaded[1];
+    let __v_53: G = __loaded[2];
+    let __v_54: G = __loaded[3];
+    let __v_55: G = __loaded[4];
+    let __v_56: G = __loaded[5];
+    let __v_57: G = __loaded[6];
+    let __v_58: G = __loaded[7];
+    let __v_59: G = __loaded[8];
+    let __v_60: G = __loaded[9];
+    let __v_61: G = __loaded[10];
+    let __v_62: G = __loaded[11];
+    let __v_63: G = __loaded[12];
+    let __v_64: G = __loaded[13];
+    let __v_65: G = __loaded[14];
+    let __v_66: G = __loaded[15];
+    let __v_67: G = __loaded[16];
+    let __v_68: G = __loaded[17];
+    let __v_69: G = __loaded[18];
+    let __v_70: G = __loaded[19];
+    let __v_71: G = __loaded[20];
+    let __v_72: G = __loaded[21];
+    let __v_73: G = __loaded[22];
+    let __v_74: G = __loaded[23];
+    let __v_75: G = __loaded[24];
+    let __v_76: G = __loaded[25];
+    let __v_77: G = __loaded[26];
+    let __v_78: G = __loaded[27];
+    let __v_79: G = __loaded[28];
+    let __v_80: G = __loaded[29];
+    let __v_81: G = __loaded[30];
+    let __v_82: G = __loaded[31];
+    let __v_83: G = G::from_u64(14);
+    if (__v_38 != __v_83) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_83.as_canonical_u64() });
+    }
+    let __v_84: G = G::from_u64(2);
+    if (__v_39 != __v_84) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_84.as_canonical_u64() });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 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];
+    let __v_88: G = G::from_u64(1);
+    let __v_89: G = G::from_u64(1);
+    if (__v_85 != __v_88) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_88.as_canonical_u64() });
+    }
+    if (__v_86 != __v_89) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_89.as_canonical_u64() });
+    }
+    if (__v_87 != __v_89) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_89.as_canonical_u64() });
+    }
+    if (__v_51 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_1.as_canonical_u64() });
+    }
+    if (__v_52 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_2.as_canonical_u64() });
+    }
+    if (__v_53 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_3.as_canonical_u64() });
+    }
+    if (__v_54 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
+    }
+    if (__v_55 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
+    }
+    if (__v_56 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_6.as_canonical_u64() });
+    }
+    if (__v_57 != __v_7) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_7.as_canonical_u64() });
+    }
+    if (__v_58 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_8.as_canonical_u64() });
+    }
+    if (__v_59 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_9.as_canonical_u64() });
+    }
+    if (__v_60 != __v_10) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
+    }
+    if (__v_61 != __v_11) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
+    }
+    if (__v_62 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
+    }
+    if (__v_63 != __v_13) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
+    }
+    if (__v_64 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
+    }
+    if (__v_65 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_15.as_canonical_u64() });
+    }
+    if (__v_66 != __v_16) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_66.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_67 != __v_17) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_67.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_68 != __v_18) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_68.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_69 != __v_19) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_69.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_70 != __v_20) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_70.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_71 != __v_21) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_71.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_72 != __v_22) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_72.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_73 != __v_23) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_73.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_74 != __v_24) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_74.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_75 != __v_25) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_75.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_76 != __v_26) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_76.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_77 != __v_27) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_77.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_78 != __v_28) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_78.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_79 != __v_29) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_79.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_80 != __v_30) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_80.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_81 != __v_31) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_81.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() });
+    if (__v_82 != __v_32) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_32.as_canonical_u64() });
     }
-    let __ret: [G; OUT_741] = [__v_51];
-    record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_744] = [__v_49];
+    record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_742: usize = 2;
-const IN_742: usize = 2;
-const OUT_742: usize = 1;
-fn aiur_fn_742(
-  inp: [G; IN_742],
+const INPUT_SIZE_745: usize = 2;
+const IN_745: usize = 2;
+const OUT_745: usize = 1;
+fn aiur_fn_745(
+  inp: [G; IN_745],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_742], ExecError> {
+) -> Result<[G; OUT_745], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63033,25 +62476,25 @@ fn aiur_fn_742(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_742] = [__v_5];
-        record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_745] = [__v_5];
+        record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_3]; 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_742] = [__v_6];
-            record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_745] = [__v_6];
+            record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_742] = [__v_6];
-            record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_745] = [__v_6];
+            record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -63063,15 +62506,15 @@ fn aiur_fn_742(
   })
 }
 
-const INPUT_SIZE_743: usize = 1;
-const IN_743: usize = 1;
-const OUT_743: usize = 1;
-fn aiur_fn_743(
-  inp: [G; IN_743],
+const INPUT_SIZE_746: usize = 1;
+const IN_746: usize = 1;
+const OUT_746: usize = 1;
+fn aiur_fn_746(
+  inp: [G; IN_746],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_743], ExecError> {
+) -> Result<[G; OUT_746], 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 };
@@ -63116,21 +62559,21 @@ fn aiur_fn_743(
     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_743] = [__v_41];
-    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_746] = [__v_41];
+    record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_744: usize = 7;
-const IN_744: usize = 7;
-const OUT_744: usize = 6;
-fn aiur_fn_744(
-  inp: [G; IN_744],
+const INPUT_SIZE_747: usize = 7;
+const IN_747: usize = 7;
+const OUT_747: usize = 6;
+fn aiur_fn_747(
+  inp: [G; IN_747],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_744], ExecError> {
+) -> Result<[G; OUT_747], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63145,29 +62588,29 @@ fn aiur_fn_744(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_744] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_747] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
+        record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
         let __v_14: G = __r_arr[3];
         let __v_15: G = __r_arr[4];
         let __v_16: G = __r_arr[5];
-        let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } };
         let __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_744] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-        record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_747] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
+        record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -63177,15 +62620,15 @@ fn aiur_fn_744(
   })
 }
 
-const INPUT_SIZE_745: usize = 7;
-const IN_745: usize = 7;
-const OUT_745: usize = 1;
-fn aiur_fn_745(
-  inp: [G; IN_745],
+const INPUT_SIZE_748: usize = 7;
+const IN_748: usize = 7;
+const OUT_748: usize = 1;
+fn aiur_fn_748(
+  inp: [G; IN_748],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_745], ExecError> {
+) -> Result<[G; OUT_748], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63194,7 +62637,7 @@ fn aiur_fn_745(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(0);
     let __v_9: G = G::from_u64(0);
@@ -63229,34 +62672,34 @@ fn aiur_fn_745(
     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_763] = { let __args: [G; IN_763] = [__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[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__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[766].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
     let __v_41: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_41, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_41, __v_0]; 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_42: G = __r_arr[0];
-    let __ret: [G; OUT_745] = [__v_42];
-    record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_748] = [__v_42];
+    record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_746: usize = 4;
-const IN_746: usize = 4;
-const OUT_746: usize = 0;
-fn aiur_fn_746(
-  inp: [G; IN_746],
+const INPUT_SIZE_749: usize = 4;
+const IN_749: usize = 4;
+const OUT_749: usize = 0;
+fn aiur_fn_749(
+  inp: [G; IN_749],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_746], ExecError> {
+) -> Result<[G; OUT_749], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_1, __v_2]; 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_4: G = G::from_u64(1);
     let __v_5: G = G::from_u64(1);
-    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     let __v_8: G = __r_arr[2];
@@ -63264,22 +62707,22 @@ fn aiur_fn_746(
     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_747] = { let __args: [G; IN_747] = [__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[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_746] = [];
-    record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } else { aiur_fn_750(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_749] = [];
+    record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_747: usize = 10;
-const IN_747: usize = 10;
-const OUT_747: usize = 0;
-fn aiur_fn_747(
-  inp: [G; IN_747],
+const INPUT_SIZE_750: usize = 10;
+const IN_750: usize = 10;
+const OUT_750: usize = 0;
+fn aiur_fn_750(
+  inp: [G; IN_750],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_747], ExecError> {
+) -> Result<[G; OUT_750], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63297,8 +62740,8 @@ fn aiur_fn_747(
     let __v_12: G = __loaded[2];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_747] = [];
-        record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_750] = [];
+        record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -63314,26 +62757,26 @@ fn aiur_fn_747(
         let __v_21: G = __loaded[8];
         let __v_22: G = __loaded[9];
         let __v_23: G = __loaded[10];
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } else { aiur_fn_748(__args, record, io_buffer, __cu)? } };
         let __v_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_747] = { let __args: [G; IN_747] = [__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[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_747] = [];
-            record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__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[750].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } else { aiur_fn_750(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_750] = [];
+            record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__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[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 __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__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[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 __v_26: G = G::from_u64(1);
             let __v_27: G = (__v_9 + __v_26);
-            let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__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[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_747] = [];
-            record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__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[750].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } else { aiur_fn_750(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_750] = [];
+            record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -63345,35 +62788,35 @@ fn aiur_fn_747(
   })
 }
 
-const INPUT_SIZE_748: usize = 3;
-const IN_748: usize = 3;
-const OUT_748: usize = 0;
-fn aiur_fn_748(
-  inp: [G; IN_748],
+const INPUT_SIZE_751: usize = 3;
+const IN_751: usize = 3;
+const OUT_751: usize = 0;
+fn aiur_fn_751(
+  inp: [G; IN_751],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_748], ExecError> {
+) -> Result<[G; OUT_751], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } else { aiur_fn_191(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0]; 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_3, __v_3, __v_4]; 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_748] = [];
-        record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_751] = [];
+        record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_3, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_748] = [];
-        record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_3, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } else { aiur_fn_749(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_751] = [];
+        record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -63383,63 +62826,63 @@ fn aiur_fn_748(
   })
 }
 
-const INPUT_SIZE_749: usize = 2;
-const IN_749: usize = 2;
-const OUT_749: usize = 0;
-fn aiur_fn_749(
-  inp: [G; IN_749],
+const INPUT_SIZE_752: usize = 2;
+const IN_752: usize = 2;
+const OUT_752: usize = 0;
+fn aiur_fn_752(
+  inp: [G; IN_752],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_749], ExecError> {
+) -> Result<[G; OUT_752], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0]; 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 __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } };
     let __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_749] = [];
-    record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_752] = [];
+    record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_750: usize = 3;
-const IN_750: usize = 3;
-const OUT_750: usize = 0;
-fn aiur_fn_750(
-  inp: [G; IN_750],
+const INPUT_SIZE_753: usize = 3;
+const IN_753: usize = 3;
+const OUT_753: usize = 0;
+fn aiur_fn_753(
+  inp: [G; IN_753],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_750], ExecError> {
+) -> Result<[G; OUT_753], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0]; 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 __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_3]; 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_4, __v_4, __v_5]; 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_750] = [];
-        record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_4, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_753] = [];
+        record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_4, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_750] = [];
-        record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_4, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } else { aiur_fn_749(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_753] = [];
+        record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -63449,15 +62892,15 @@ fn aiur_fn_750(
   })
 }
 
-const INPUT_SIZE_751: usize = 55;
-const IN_751: usize = 55;
-const OUT_751: usize = 0;
-fn aiur_fn_751(
-  inp: [G; IN_751],
+const INPUT_SIZE_754: usize = 55;
+const IN_754: usize = 55;
+const OUT_754: usize = 0;
+fn aiur_fn_754(
+  inp: [G; IN_754],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_751], ExecError> {
+) -> Result<[G; OUT_754], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63514,7 +62957,7 @@ fn aiur_fn_751(
     let __v_52: G = inp[52];
     let __v_53: G = inp[53];
     let __v_54: G = inp[54];
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0]; 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_55: G = __r_arr[0];
     let __v_56: G = __r_arr[1];
     let __v_57: G = __r_arr[2];
@@ -63571,13 +63014,13 @@ fn aiur_fn_751(
               0u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_57, __v_4, __v_5]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_66, __v_15, __v_16]; 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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_67, __v_17, __v_18]; 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 __ret: [G; OUT_751] = [];
-                    record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_57, __v_4, __v_5]; 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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_66, __v_15, __v_16]; 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 __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_67, __v_17, __v_18]; 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 __ret: [G; OUT_754] = [];
+                    record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63592,17 +63035,17 @@ fn aiur_fn_751(
               1u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_57, __v_4, __v_5]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_98, __v_51, __v_52]; 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 __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_99, __v_53, __v_54]; 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 __ret: [G; OUT_751] = [];
-                    record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_57, __v_4, __v_5]; 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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_98, __v_51, __v_52]; 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 __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_99, __v_53, __v_54]; 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 __ret: [G; OUT_754] = [];
+                    record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63617,11 +63060,11 @@ fn aiur_fn_751(
               2u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_751] = [];
-                    record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_754] = [];
+                    record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63636,11 +63079,11 @@ fn aiur_fn_751(
               3u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_751] = [];
-                    record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_754] = [];
+                    record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63655,11 +63098,11 @@ fn aiur_fn_751(
               4u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_72, __v_20, __v_21]; 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 __ret: [G; OUT_751] = [];
-                    record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_72, __v_20, __v_21]; 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 __ret: [G; OUT_754] = [];
+                    record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63674,10 +63117,10 @@ fn aiur_fn_751(
               5u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_751] = [];
-                    record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_754] = [];
+                    record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63692,10 +63135,10 @@ fn aiur_fn_751(
               6u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_751] = [];
-                    record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_754] = [];
+                    record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63710,10 +63153,10 @@ fn aiur_fn_751(
               7u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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 __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_751] = [];
-                    record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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 __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_754] = [];
+                    record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63726,9 +63169,9 @@ fn aiur_fn_751(
           8u64 => {
             match __v_1.as_canonical_u64() {
               8u64 => {
-                let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2]; 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 __ret: [G; OUT_751] = [];
-                record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_56, __v_2]; 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 __ret: [G; OUT_754] = [];
+                record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -63745,15 +63188,15 @@ fn aiur_fn_751(
   })
 }
 
-const INPUT_SIZE_752: usize = 4;
-const IN_752: usize = 4;
-const OUT_752: usize = 0;
-fn aiur_fn_752(
-  inp: [G; IN_752],
+const INPUT_SIZE_755: usize = 4;
+const IN_755: usize = 4;
+const OUT_755: usize = 0;
+fn aiur_fn_755(
+  inp: [G; IN_755],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_752], ExecError> {
+) -> Result<[G; OUT_755], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63764,21 +63207,21 @@ fn aiur_fn_752(
     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_752] = [];
-    record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_755] = [];
+    record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_753: usize = 32;
-const IN_753: usize = 32;
-const OUT_753: usize = 0;
-fn aiur_fn_753(
-  inp: [G; IN_753],
+const INPUT_SIZE_756: usize = 32;
+const IN_756: usize = 32;
+const OUT_756: usize = 0;
+fn aiur_fn_756(
+  inp: [G; IN_756],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_753], ExecError> {
+) -> Result<[G; OUT_756], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63812,7 +63255,7 @@ fn aiur_fn_753(
     let __v_29: G = inp[29];
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
-    let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[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 __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[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_32: G = __r_arr[0];
     let __v_33: G = __r_arr[1];
     let __v_34: G = __r_arr[2];
@@ -63871,33 +63314,33 @@ fn aiur_fn_753(
     let __v_87: G = __r_arr[55];
     match __v_32.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } else { aiur_fn_752(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_753] = [];
-        record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } else { aiur_fn_755(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_756] = [];
+        record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } else { aiur_fn_748(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_753] = [];
-        record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[751].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_751] = unsafe { *(result.output.as_ptr() as *const [G; OUT_751]) }; __ret } else { aiur_fn_751(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_756] = [];
+        record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } else { aiur_fn_750(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_753] = [];
-        record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } else { aiur_fn_753(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_756] = [];
+        record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_33, __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[751].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_751] = unsafe { *(result.output.as_ptr() as *const [G; OUT_751]) }; __ret } else { aiur_fn_751(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_753] = [];
-        record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_33, __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[754].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } else { aiur_fn_754(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_756] = [];
+        record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } else { aiur_fn_749(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_753] = [];
-        record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } else { aiur_fn_752(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_756] = [];
+        record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -63907,15 +63350,15 @@ fn aiur_fn_753(
   })
 }
 
-const INPUT_SIZE_754: usize = 32;
-const IN_754: usize = 32;
-const OUT_754: usize = 0;
-fn aiur_fn_754(
-  inp: [G; IN_754],
+const INPUT_SIZE_757: usize = 32;
+const IN_757: usize = 32;
+const OUT_757: usize = 0;
+fn aiur_fn_757(
+  inp: [G; IN_757],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_754], ExecError> {
+) -> Result<[G; OUT_757], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63950,13 +63393,13 @@ fn aiur_fn_754(
     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_191] = { let __args: [G; IN_191] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } else { aiur_fn_191(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_32]; 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_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_456] = { let __args: [G; IN_456] = [__v_32, __v_34, __v_35]; 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 __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_32, __v_34, __v_35]; 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_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_33, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_33, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
     let __v_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];
@@ -63970,28 +63413,28 @@ fn aiur_fn_754(
     let __v_46: G = __loaded[8];
     let __v_47: G = __loaded[9];
     let __v_48: G = __loaded[10];
-    let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__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[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_754] = [];
-    record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__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[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_757] = [];
+    record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_755: usize = 1;
-const IN_755: usize = 1;
-const OUT_755: usize = 0;
-fn aiur_fn_755(
-  inp: [G; IN_755],
+const INPUT_SIZE_758: usize = 1;
+const IN_758: usize = 1;
+const OUT_758: usize = 0;
+fn aiur_fn_758(
+  inp: [G; IN_758],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_755], ExecError> {
+) -> Result<[G; OUT_758], 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_755] = [];
-        record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_758] = [];
+        record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64004,7 +63447,7 @@ fn aiur_fn_755(
         let __v_6: G = G::from_u64(0);
         let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7]; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         let __v_10: G = __r_arr[2];
@@ -64054,47 +63497,47 @@ fn aiur_fn_755(
         let __v_54: G = __r_arr[46];
         let __v_55: G = __r_arr[47];
         let __v_56: G = __r_arr[48];
+        let __v_57: G = G::from_u64(1);
+        let __v_58: G = G::from_u64(1);
+        let __v_59: G = { let __values: [G; 3] = [__v_57, __v_58, __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 __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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_59]; 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_60: 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_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() });
+        let __v_61: G = __loaded[0];
+        let __v_62: G = __loaded[1];
+        let __v_63: G = __loaded[2];
+        let __v_64: G = G::from_u64(1);
+        let __v_65: G = G::from_u64(1);
+        if (__v_61 != __v_64) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_64.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_62 != __v_65) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_65.as_canonical_u64() });
         }
-        if (__v_59 != __v_61) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_61.as_canonical_u64() });
+        if (__v_63 != __v_65) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_65.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_69] = { let __args: [G; IN_69] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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_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() });
+        if (__v_7 != __v_60) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_60.as_canonical_u64() });
         }
-        let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } else { aiur_fn_755(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_755] = [];
-        record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } else { aiur_fn_758(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_758] = [];
+        record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_756: usize = 0;
-const IN_756: usize = 0;
-const OUT_756: usize = 0;
-fn aiur_fn_756(
-  inp: [G; IN_756],
+const INPUT_SIZE_759: usize = 0;
+const IN_759: usize = 0;
+const OUT_759: usize = 0;
+fn aiur_fn_759(
+  inp: [G; IN_759],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_756], ExecError> {
+) -> Result<[G; OUT_759], 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);
@@ -64113,161 +63556,161 @@ fn aiur_fn_756(
     let __v_14: G = G::from_u64(1);
     let __v_15: G = G::from_u64(0);
     let __v_16: G = { let __values: [G; 3] = [__v_14, __v_2, __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_224] = { let __args: [G; IN_224] = [__v_2, __v_6]; 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_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 __v_17: G = G::from_u64(2);
+    let __v_18: G = { let __values: [G; 3] = [__v_17, __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 __v_19: G = G::from_u64(3);
+    let __v_20: G = { let __values: [G; 3] = [__v_19, __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 __v_21: G = G::from_u64(2);
+    let __v_22: G = G::from_u64(3);
+    let __v_23: G = { let __values: [G; 3] = [__v_22, __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 __v_24: G = { let __values: [G; 3] = [__v_21, __v_16, __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(0);
+    let __v_27: G = { let __values: [G; 3] = [__v_25, __v_10, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_2, __v_6]; 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_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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_6, __v_6]; 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_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 __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_6]; 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_30: G = __r_arr[0];
+    let __v_31: G = G::from_u64(1);
+    if (__v_30 != __v_31) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64() });
     }
-    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_6, __v_10]; 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_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 __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __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_32: G = __r_arr[0];
+    let __v_33: G = G::from_u64(0);
+    if (__v_32 != __v_33) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64() });
     }
-    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_13, __v_13]; 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_23: G = __r_arr[0];
-    let __v_24: G = G::from_u64(1);
-    if (__v_23 != __v_24) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64() });
+    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_13, __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_34: G = __r_arr[0];
+    let __v_35: G = G::from_u64(1);
+    if (__v_34 != __v_35) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64() });
     }
-    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_13, __v_6]; 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_25: G = __r_arr[0];
-    let __v_26: G = G::from_u64(0);
-    if (__v_25 != __v_26) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64() });
+    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_13, __v_6]; 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_36: G = __r_arr[0];
+    let __v_37: G = G::from_u64(0);
+    if (__v_36 != __v_37) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_37.as_canonical_u64() });
     }
-    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_6, __v_13]; 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_27: G = __r_arr[0];
-    let __v_28: G = G::from_u64(1);
-    if (__v_27 != __v_28) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64() });
+    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __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_38: G = __r_arr[0];
+    let __v_39: G = G::from_u64(1);
+    if (__v_38 != __v_39) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_39.as_canonical_u64() });
     }
-    let __v_29: G = G::from_u64(2);
-    let __v_30: G = { let __values: [G; 3] = [__v_29, __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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_30, __v_30]; 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_31: G = __r_arr[0];
-    let __v_32: G = G::from_u64(1);
-    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_227] = { let __args: [G; IN_227] = [__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_40: G = __r_arr[0];
+    let __v_41: G = G::from_u64(1);
+    if (__v_40 != __v_41) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_41.as_canonical_u64() });
     }
-    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_6, __v_30]; 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_33: G = __r_arr[0];
-    let __v_34: G = G::from_u64(1);
-    if (__v_33 != __v_34) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64() });
+    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __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_42: G = __r_arr[0];
+    let __v_43: G = G::from_u64(1);
+    if (__v_42 != __v_43) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_43.as_canonical_u64() });
     }
-    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_30, __v_6]; 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_35: G = __r_arr[0];
-    let __v_36: G = G::from_u64(0);
-    if (__v_35 != __v_36) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64() });
+    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_18, __v_6]; 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_44: G = __r_arr[0];
+    let __v_45: G = G::from_u64(0);
+    if (__v_44 != __v_45) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64() });
     }
-    let __v_37: G = G::from_u64(3);
-    let __v_38: G = { let __values: [G; 3] = [__v_37, __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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_38, __v_30]; 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_39: G = __r_arr[0];
-    let __v_40: G = G::from_u64(1);
-    if (__v_39 != __v_40) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64() });
+    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_20, __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_46: G = __r_arr[0];
+    let __v_47: G = G::from_u64(1);
+    if (__v_46 != __v_47) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_47.as_canonical_u64() });
     }
-    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_30, __v_38]; 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_41: G = __r_arr[0];
-    let __v_42: G = G::from_u64(0);
-    if (__v_41 != __v_42) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64() });
-    }
-    let __v_43: G = G::from_u64(2);
-    let __v_44: G = G::from_u64(3);
-    let __v_45: G = { let __values: [G; 3] = [__v_44, __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 __v_46: G = { let __values: [G; 3] = [__v_43, __v_16, __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 __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_13, __v_46]; 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_47: G = __r_arr[0];
-    let __v_48: G = G::from_u64(1);
-    if (__v_47 != __v_48) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_48.as_canonical_u64() });
+    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_18, __v_20]; 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_48: G = __r_arr[0];
+    let __v_49: G = G::from_u64(0);
+    if (__v_48 != __v_49) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_49.as_canonical_u64() });
     }
-    let __v_49: G = G::from_u64(3);
-    let __v_50: G = { let __values: [G; 3] = [__v_49, __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_225] = { let __args: [G; IN_225] = [__v_50, __v_6]; 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_51: G = __r_arr[0];
-    let __v_52: G = G::from_u64(1);
-    if (__v_51 != __v_52) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64() });
+    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_13, __v_24]; 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_50: G = __r_arr[0];
+    let __v_51: G = G::from_u64(1);
+    if (__v_50 != __v_51) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_51.as_canonical_u64() });
     }
-    let __v_53: G = G::from_u64(2);
-    let __v_54: G = { let __values: [G; 3] = [__v_53, __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_225] = { let __args: [G; IN_225] = [__v_54, __v_6]; 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_55: G = __r_arr[0];
-    let __v_56: G = G::from_u64(1);
-    if (__v_55 != __v_56) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_56.as_canonical_u64() });
+    let __v_52: G = G::from_u64(3);
+    let __v_53: G = { let __values: [G; 3] = [__v_52, __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_228] = { let __args: [G; IN_228] = [__v_53, __v_6]; 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_54: G = __r_arr[0];
+    let __v_55: G = G::from_u64(1);
+    if (__v_54 != __v_55) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64() });
     }
-    let __v_57: G = G::from_u64(1);
-    let __v_58: G = G::from_u64(0);
-    let __v_59: G = { let __values: [G; 3] = [__v_57, __v_10, __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 __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_59]; 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_56: G = G::from_u64(2);
+    let __v_57: G = { let __values: [G; 3] = [__v_56, __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_228] = { let __args: [G; IN_228] = [__v_57, __v_6]; 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_58: G = __r_arr[0];
+    let __v_59: G = G::from_u64(1);
+    if (__v_58 != __v_59) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_59.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_27]; 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_60: G = __r_arr[0];
     let __v_61: G = G::from_u64(2);
-    let __v_62: G = { let __values: [G; 3] = [__v_61, __v_6, __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 __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_60, __v_62]; 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_62: G = { let __values: [G; 3] = [__v_61, __v_6, __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_203] = { let __args: [G; IN_203] = [__v_60, __v_62]; 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_63: G = __r_arr[0];
     let __v_64: G = G::from_u64(1);
     if (__v_63 != __v_64) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_64.as_canonical_u64() });
     }
-    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_2]; 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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_2]; 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_65: G = __r_arr[0];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_65, __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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_65, __v_2]; 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_66: G = __r_arr[0];
     let __v_67: G = G::from_u64(1);
     if (__v_66 != __v_67) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64() });
     }
-    let __ret: [G; OUT_756] = [];
-    record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_759] = [];
+    record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_757: usize = 0;
-const IN_757: usize = 0;
-const OUT_757: usize = 0;
-fn aiur_fn_757(
-  inp: [G; IN_757],
+const INPUT_SIZE_760: usize = 0;
+const IN_760: usize = 0;
+const OUT_760: usize = 0;
+fn aiur_fn_760(
+  inp: [G; IN_760],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_757], ExecError> {
+) -> Result<[G; OUT_760], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } else { aiur_fn_756(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_757] = [];
-    record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_760] = [];
+    record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_758: usize = 1;
-const IN_758: usize = 1;
-const OUT_758: usize = 0;
-fn aiur_fn_758(
-  inp: [G; IN_758],
+const INPUT_SIZE_761: usize = 1;
+const IN_761: usize = 1;
+const OUT_761: usize = 0;
+fn aiur_fn_761(
+  inp: [G; IN_761],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_758], ExecError> {
+) -> Result<[G; OUT_761], 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_758] = [];
-        record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_761] = [];
+        record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64280,7 +63723,7 @@ fn aiur_fn_758(
         let __v_6: G = G::from_u64(0);
         let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7]; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         let __v_10: G = __r_arr[2];
@@ -64330,27 +63773,27 @@ fn aiur_fn_758(
         let __v_54: G = __r_arr[46];
         let __v_55: G = __r_arr[47];
         let __v_56: G = __r_arr[48];
+        let __v_57: G = G::from_u64(1);
+        let __v_58: G = G::from_u64(1);
+        let __v_59: G = { let __values: [G; 3] = [__v_57, __v_58, __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 __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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_59]; 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_60: 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_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() });
+        let __v_61: G = __loaded[0];
+        let __v_62: G = __loaded[1];
+        let __v_63: G = __loaded[2];
+        let __v_64: G = G::from_u64(1);
+        let __v_65: G = G::from_u64(1);
+        if (__v_61 != __v_64) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_64.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_62 != __v_65) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_65.as_canonical_u64() });
         }
-        if (__v_59 != __v_61) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_61.as_canonical_u64() });
+        if (__v_63 != __v_65) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_65.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_69] = { let __args: [G; IN_69] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[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_65: G = __r_arr[0];
-        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7]; 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 __v_67: G = __r_arr[1];
         let __v_68: G = __r_arr[2];
@@ -64383,7 +63826,7 @@ fn aiur_fn_758(
         let __v_95: G = __r_arr[29];
         let __v_96: G = __r_arr[30];
         let __v_97: G = __r_arr[31];
-        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_60]; 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_98: G = __r_arr[0];
         let __v_99: G = __r_arr[1];
         let __v_100: G = __r_arr[2];
@@ -64512,24 +63955,24 @@ fn aiur_fn_758(
         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_758] = { let __args: [G; IN_758] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } else { aiur_fn_758(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_758] = [];
-        record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } else { aiur_fn_761(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_761] = [];
+        record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_759: usize = 2;
-const IN_759: usize = 2;
-const OUT_759: usize = 1;
-fn aiur_fn_759(
-  inp: [G; IN_759],
+const INPUT_SIZE_762: usize = 2;
+const IN_762: usize = 2;
+const OUT_762: usize = 1;
+fn aiur_fn_762(
+  inp: [G; IN_762],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_759], ExecError> {
+) -> Result<[G; OUT_762], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64544,17 +63987,17 @@ fn aiur_fn_759(
         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_759] = [__v_9];
-        record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_762] = [__v_9];
+        record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_759] = [__v_7];
-        record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_762] = [__v_7];
+        record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64564,15 +64007,15 @@ fn aiur_fn_759(
   })
 }
 
-const INPUT_SIZE_760: usize = 1;
-const IN_760: usize = 1;
-const OUT_760: usize = 8;
-fn aiur_fn_760(
-  inp: [G; IN_760],
+const INPUT_SIZE_763: usize = 1;
+const IN_763: usize = 1;
+const OUT_763: usize = 8;
+fn aiur_fn_763(
+  inp: [G; IN_763],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_760], ExecError> {
+) -> Result<[G; OUT_763], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
@@ -64596,12 +64039,12 @@ fn aiur_fn_760(
         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_760] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
-        record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_763] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
+        record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -64610,7 +64053,7 @@ fn aiur_fn_760(
         let __v_16: G = __r_arr[5];
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
-        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -64619,8 +64062,8 @@ fn aiur_fn_760(
         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_760] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_763] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64630,15 +64073,15 @@ fn aiur_fn_760(
   })
 }
 
-const INPUT_SIZE_761: usize = 1;
-const IN_761: usize = 1;
-const OUT_761: usize = 8;
-fn aiur_fn_761(
-  inp: [G; IN_761],
+const INPUT_SIZE_764: usize = 1;
+const IN_764: usize = 1;
+const OUT_764: usize = 8;
+fn aiur_fn_764(
+  inp: [G; IN_764],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_761], ExecError> {
+) -> Result<[G; OUT_764], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -64655,12 +64098,12 @@ fn aiur_fn_761(
         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_761] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
-        record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_764] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } else { aiur_fn_761(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         let __v_6: G = __r_arr[2];
@@ -64669,7 +64112,7 @@ fn aiur_fn_761(
         let __v_9: G = __r_arr[5];
         let __v_10: G = __r_arr[6];
         let __v_11: G = __r_arr[7];
-        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -64678,8 +64121,8 @@ fn aiur_fn_761(
         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_761] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_764] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+        record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64689,15 +64132,15 @@ fn aiur_fn_761(
   })
 }
 
-const INPUT_SIZE_762: usize = 2;
-const IN_762: usize = 2;
-const OUT_762: usize = 1;
-fn aiur_fn_762(
-  inp: [G; IN_762],
+const INPUT_SIZE_765: usize = 2;
+const IN_765: usize = 2;
+const OUT_765: usize = 1;
+fn aiur_fn_765(
+  inp: [G; IN_765],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_762], ExecError> {
+) -> Result<[G; OUT_765], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64707,17 +64150,17 @@ fn aiur_fn_762(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_762] = [__v_1];
-        record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_765] = [__v_1];
+        record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
         let __v_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_762] = [__v_7];
-        record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_765] = [__v_7];
+        record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64727,15 +64170,15 @@ fn aiur_fn_762(
   })
 }
 
-const INPUT_SIZE_763: usize = 8;
-const IN_763: usize = 8;
-const OUT_763: usize = 1;
-fn aiur_fn_763(
-  inp: [G; IN_763],
+const INPUT_SIZE_766: usize = 8;
+const IN_766: usize = 8;
+const OUT_766: usize = 1;
+fn aiur_fn_766(
+  inp: [G; IN_766],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_763], ExecError> {
+) -> Result<[G; OUT_766], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64747,8 +64190,8 @@ fn aiur_fn_763(
     let __v_7: G = inp[7];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_763] = [__v_7];
-        record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_766] = [__v_7];
+        record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -64769,25 +64212,25 @@ fn aiur_fn_763(
         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_763] = { let __args: [G; IN_763] = [__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[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__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[766].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_763] = [__v_21];
-            record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_766] = [__v_21];
+            record.function_queries[766].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_763] = [__v_4];
-                record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_766] = [__v_4];
+                record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__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[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__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[766].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
-                let __ret: [G; OUT_763] = [__v_22];
-                record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_766] = [__v_22];
+                record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -64801,15 +64244,15 @@ fn aiur_fn_763(
   })
 }
 
-const INPUT_SIZE_764: usize = 2;
-const IN_764: usize = 2;
-const OUT_764: usize = 1;
-fn aiur_fn_764(
-  inp: [G; IN_764],
+const INPUT_SIZE_767: usize = 2;
+const IN_767: usize = 2;
+const OUT_767: usize = 1;
+fn aiur_fn_767(
+  inp: [G; IN_767],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_764], ExecError> {
+) -> Result<[G; OUT_767], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64821,17 +64264,17 @@ fn aiur_fn_764(
     let __v_6: G = __loaded[4];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_764] = [__v_1];
-        record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_767] = [__v_1];
+        record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
         let __v_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_764] = [__v_9];
-        record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_767] = [__v_9];
+        record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64841,37 +64284,37 @@ fn aiur_fn_764(
   })
 }
 
-const INPUT_SIZE_765: usize = 1;
-const IN_765: usize = 1;
-const OUT_765: usize = 1;
-fn aiur_fn_765(
-  inp: [G; IN_765],
+const INPUT_SIZE_768: usize = 1;
+const IN_768: usize = 1;
+const OUT_768: usize = 1;
+fn aiur_fn_768(
+  inp: [G; IN_768],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_765], ExecError> {
+) -> Result<[G; OUT_768], 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_788] = { let __args: [G; IN_788] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[791].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_791] = unsafe { *(result.output.as_ptr() as *const [G; OUT_791]) }; __ret } else { aiur_fn_791(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_765] = [__v_4];
-    record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_768] = [__v_4];
+    record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_766: usize = 1;
-const IN_766: usize = 1;
-const OUT_766: usize = 8;
-fn aiur_fn_766(
-  inp: [G; IN_766],
+const INPUT_SIZE_769: usize = 1;
+const IN_769: usize = 1;
+const OUT_769: usize = 8;
+fn aiur_fn_769(
+  inp: [G; IN_769],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_766], ExecError> {
+) -> Result<[G; OUT_769], 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 };
@@ -64921,12 +64364,12 @@ fn aiur_fn_766(
         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_766] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44];
-        record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_769] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44];
+        record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
         let __v_38: G = __r_arr[1];
         let __v_39: G = __r_arr[2];
@@ -64935,7 +64378,7 @@ fn aiur_fn_766(
         let __v_42: G = __r_arr[5];
         let __v_43: G = __r_arr[6];
         let __v_44: G = __r_arr[7];
-        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[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_45: G = __r_arr[0];
         let __v_46: G = __r_arr[1];
         let __v_47: G = __r_arr[2];
@@ -64944,8 +64387,8 @@ fn aiur_fn_766(
         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_766] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52];
-        record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_769] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52];
+        record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64955,19 +64398,19 @@ fn aiur_fn_766(
   })
 }
 
-const INPUT_SIZE_767: usize = 2;
-const IN_767: usize = 2;
-const OUT_767: usize = 1;
-fn aiur_fn_767(
-  inp: [G; IN_767],
+const INPUT_SIZE_770: usize = 2;
+const IN_770: usize = 2;
+const OUT_770: usize = 1;
+fn aiur_fn_770(
+  inp: [G; IN_770],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_767], ExecError> {
+) -> Result<[G; OUT_770], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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];
@@ -64975,8 +64418,8 @@ fn aiur_fn_767(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_767] = [__v_4];
-        record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_770] = [__v_4];
+        record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64986,15 +64429,15 @@ fn aiur_fn_767(
   })
 }
 
-const INPUT_SIZE_768: usize = 9;
-const IN_768: usize = 9;
-const OUT_768: usize = 1;
-fn aiur_fn_768(
-  inp: [G; IN_768],
+const INPUT_SIZE_771: usize = 9;
+const IN_771: usize = 9;
+const OUT_771: usize = 1;
+fn aiur_fn_771(
+  inp: [G; IN_771],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_768], ExecError> {
+) -> Result<[G; OUT_771], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65015,12 +64458,12 @@ fn aiur_fn_768(
         let __v_12: G = __r_arr[0];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_768] = [__v_10];
-            record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_771] = [__v_10];
+            record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             let __v_15: G = __r_arr[2];
@@ -65029,10 +64472,10 @@ fn aiur_fn_768(
             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_768] = { let __args: [G; IN_768] = [__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[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__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[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_768] = [__v_21];
-            record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_771] = [__v_21];
+            record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65047,15 +64490,15 @@ fn aiur_fn_768(
   })
 }
 
-const INPUT_SIZE_769: usize = 1;
-const IN_769: usize = 1;
-const OUT_769: usize = 1;
-fn aiur_fn_769(
-  inp: [G; IN_769],
+const INPUT_SIZE_772: usize = 1;
+const IN_772: usize = 1;
+const OUT_772: usize = 1;
+fn aiur_fn_772(
+  inp: [G; IN_772],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_769], ExecError> {
+) -> Result<[G; OUT_772], 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 };
@@ -65072,17 +64515,17 @@ fn aiur_fn_769(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_769] = [__v_11];
-        record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_772] = [__v_11];
+        record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
         let __v_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_769] = [__v_13];
-        record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_772] = [__v_13];
+        record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65092,15 +64535,15 @@ fn aiur_fn_769(
   })
 }
 
-const INPUT_SIZE_770: usize = 7;
-const IN_770: usize = 7;
-const OUT_770: usize = 1;
-fn aiur_fn_770(
-  inp: [G; IN_770],
+const INPUT_SIZE_773: usize = 7;
+const IN_773: usize = 7;
+const OUT_773: usize = 1;
+fn aiur_fn_773(
+  inp: [G; IN_773],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_770], ExecError> {
+) -> Result<[G; OUT_773], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65128,25 +64571,25 @@ fn aiur_fn_770(
         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_770] = { let __args: [G; IN_770] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
-            let __ret: [G; OUT_770] = [__v_20];
-            record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_773] = [__v_20];
+            record.function_queries[773].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_770] = [__v_4];
-                record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_773] = [__v_4];
+                record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
                 let __v_21: G = __r_arr[0];
-                let __ret: [G; OUT_770] = [__v_21];
-                record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_773] = [__v_21];
+                record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -65160,15 +64603,15 @@ fn aiur_fn_770(
   })
 }
 
-const INPUT_SIZE_771: usize = 9;
-const IN_771: usize = 9;
-const OUT_771: usize = 45;
-fn aiur_fn_771(
-  inp: [G; IN_771],
+const INPUT_SIZE_774: usize = 9;
+const IN_774: usize = 9;
+const OUT_774: usize = 45;
+fn aiur_fn_774(
+  inp: [G; IN_774],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_771], ExecError> {
+) -> Result<[G; OUT_774], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65233,12 +64676,12 @@ fn aiur_fn_771(
         let __v_56: G = __r_arr[0];
         match __v_56.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_771] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __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[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_774] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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_57: G = __r_arr[0];
             let __v_58: G = __r_arr[1];
             let __v_59: G = __r_arr[2];
@@ -65247,7 +64690,7 @@ fn aiur_fn_771(
             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_771] = { let __args: [G; IN_771] = [__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[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__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[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
             let __v_65: G = __r_arr[0];
             let __v_66: G = __r_arr[1];
             let __v_67: G = __r_arr[2];
@@ -65293,8 +64736,8 @@ fn aiur_fn_771(
             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_771] = [__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[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_774] = [__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[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65309,15 +64752,15 @@ fn aiur_fn_771(
   })
 }
 
-const INPUT_SIZE_772: usize = 2;
-const IN_772: usize = 2;
-const OUT_772: usize = 1;
-fn aiur_fn_772(
-  inp: [G; IN_772],
+const INPUT_SIZE_775: usize = 2;
+const IN_775: usize = 2;
+const OUT_775: usize = 1;
+fn aiur_fn_775(
+  inp: [G; IN_775],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_772], ExecError> {
+) -> Result<[G; OUT_775], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65330,17 +64773,17 @@ fn aiur_fn_772(
     let __v_7: G = __loaded[5];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_772] = [__v_1];
-        record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_775] = [__v_1];
+        record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = { 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_772] = [__v_10];
-        record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_775] = [__v_10];
+        record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65350,15 +64793,15 @@ fn aiur_fn_772(
   })
 }
 
-const INPUT_SIZE_773: usize = 1;
-const IN_773: usize = 1;
-const OUT_773: usize = 8;
-fn aiur_fn_773(
-  inp: [G; IN_773],
+const INPUT_SIZE_776: usize = 1;
+const IN_776: usize = 1;
+const OUT_776: usize = 8;
+fn aiur_fn_776(
+  inp: [G; IN_776],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_773], ExecError> {
+) -> Result<[G; OUT_776], 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 };
@@ -65419,12 +64862,12 @@ fn aiur_fn_773(
         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_773] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55];
-        record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_776] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55];
+        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
         let __v_48: G = __r_arr[0];
         let __v_49: G = __r_arr[1];
         let __v_50: G = __r_arr[2];
@@ -65433,7 +64876,7 @@ fn aiur_fn_773(
         let __v_53: G = __r_arr[5];
         let __v_54: G = __r_arr[6];
         let __v_55: G = __r_arr[7];
-        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[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_56: G = __r_arr[0];
         let __v_57: G = __r_arr[1];
         let __v_58: G = __r_arr[2];
@@ -65442,8 +64885,8 @@ fn aiur_fn_773(
         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_773] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-        record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_776] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
+        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65453,15 +64896,15 @@ fn aiur_fn_773(
   })
 }
 
-const INPUT_SIZE_774: usize = 8;
-const IN_774: usize = 8;
-const OUT_774: usize = 6;
-fn aiur_fn_774(
-  inp: [G; IN_774],
+const INPUT_SIZE_777: usize = 8;
+const IN_777: usize = 8;
+const OUT_777: usize = 6;
+fn aiur_fn_777(
+  inp: [G; IN_777],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_774], ExecError> {
+) -> Result<[G; OUT_777], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65471,7 +64914,7 @@ fn aiur_fn_774(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__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[789].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_789] = unsafe { *(result.output.as_ptr() as *const [G; OUT_789]) }; __ret } else { aiur_fn_789(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__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[792].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_792] = unsafe { *(result.output.as_ptr() as *const [G; OUT_792]) }; __ret } else { aiur_fn_792(__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];
@@ -65482,8 +64925,8 @@ fn aiur_fn_774(
       0u64 => {
         let __v_14: G = G::from_u64(0);
         let __v_15: G = G::from_u64(1);
-        let __ret: [G; OUT_774] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13];
-        record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_777] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13];
+        record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65493,15 +64936,15 @@ fn aiur_fn_774(
   })
 }
 
-const INPUT_SIZE_775: usize = 1;
-const IN_775: usize = 1;
-const OUT_775: usize = 8;
-fn aiur_fn_775(
-  inp: [G; IN_775],
+const INPUT_SIZE_778: usize = 1;
+const IN_778: usize = 1;
+const OUT_778: usize = 8;
+fn aiur_fn_778(
+  inp: [G; IN_778],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_775], ExecError> {
+) -> Result<[G; OUT_778], 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 };
@@ -65526,12 +64969,12 @@ fn aiur_fn_775(
         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_775] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_778] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+        record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -65540,7 +64983,7 @@ fn aiur_fn_775(
         let __v_17: G = __r_arr[5];
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
-        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -65549,8 +64992,8 @@ fn aiur_fn_775(
         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_775] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27];
-        record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_778] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27];
+        record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65560,15 +65003,15 @@ fn aiur_fn_775(
   })
 }
 
-const INPUT_SIZE_776: usize = 2;
-const IN_776: usize = 2;
-const OUT_776: usize = 1;
-fn aiur_fn_776(
-  inp: [G; IN_776],
+const INPUT_SIZE_779: usize = 2;
+const IN_779: usize = 2;
+const OUT_779: usize = 1;
+fn aiur_fn_779(
+  inp: [G; IN_779],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_776], ExecError> {
+) -> Result<[G; OUT_779], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65579,17 +65022,17 @@ fn aiur_fn_776(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_776] = [__v_1];
-        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_779] = [__v_1];
+        record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } else { aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = { 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_776] = [__v_8];
-        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_779] = [__v_8];
+        record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65599,15 +65042,15 @@ fn aiur_fn_776(
   })
 }
 
-const INPUT_SIZE_777: usize = 9;
-const IN_777: usize = 9;
-const OUT_777: usize = 34;
-fn aiur_fn_777(
-  inp: [G; IN_777],
+const INPUT_SIZE_780: usize = 9;
+const IN_780: usize = 9;
+const OUT_780: usize = 34;
+fn aiur_fn_780(
+  inp: [G; IN_780],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_777], ExecError> {
+) -> Result<[G; OUT_780], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65661,12 +65104,12 @@ fn aiur_fn_777(
         let __v_45: G = __r_arr[0];
         match __v_45.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_777] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_780] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !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_46: G = __r_arr[0];
             let __v_47: G = __r_arr[1];
             let __v_48: G = __r_arr[2];
@@ -65675,7 +65118,7 @@ fn aiur_fn_777(
             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_777] = { let __args: [G; IN_777] = [__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[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__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[780].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } else { aiur_fn_780(__args, record, io_buffer, __cu)? } };
             let __v_54: G = __r_arr[0];
             let __v_55: G = __r_arr[1];
             let __v_56: G = __r_arr[2];
@@ -65710,8 +65153,8 @@ fn aiur_fn_777(
             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_777] = [__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[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_780] = [__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[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65726,15 +65169,15 @@ fn aiur_fn_777(
   })
 }
 
-const INPUT_SIZE_778: usize = 1;
-const IN_778: usize = 1;
-const OUT_778: usize = 1;
-fn aiur_fn_778(
-  inp: [G; IN_778],
+const INPUT_SIZE_781: usize = 1;
+const IN_781: usize = 1;
+const OUT_781: usize = 1;
+fn aiur_fn_781(
+  inp: [G; IN_781],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_778], ExecError> {
+) -> Result<[G; OUT_781], 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 };
@@ -65744,14 +65187,14 @@ fn aiur_fn_778(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_778] = [__v_4];
-        record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_781] = [__v_4];
+        record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_778] = [__v_4];
-        record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_781] = [__v_4];
+        record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65761,19 +65204,19 @@ fn aiur_fn_778(
   })
 }
 
-const INPUT_SIZE_779: usize = 2;
-const IN_779: usize = 2;
-const OUT_779: usize = 3;
-fn aiur_fn_779(
-  inp: [G; IN_779],
+const INPUT_SIZE_782: usize = 2;
+const IN_782: usize = 2;
+const OUT_782: usize = 3;
+fn aiur_fn_782(
+  inp: [G; IN_782],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_779], ExecError> {
+) -> Result<[G; OUT_782], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[790].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_790] = unsafe { *(result.output.as_ptr() as *const [G; OUT_790]) }; __ret } else { aiur_fn_790(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[793].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_793] = unsafe { *(result.output.as_ptr() as *const [G; OUT_793]) }; __ret } else { aiur_fn_793(__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];
@@ -65783,8 +65226,8 @@ fn aiur_fn_779(
     let __v_7: G = __loaded[4];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_779] = [__v_4, __v_5, __v_6];
-        record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_782] = [__v_4, __v_5, __v_6];
+        record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65794,28 +65237,28 @@ fn aiur_fn_779(
   })
 }
 
-const INPUT_SIZE_780: usize = 2;
-const IN_780: usize = 2;
-const OUT_780: usize = 1;
-fn aiur_fn_780(
-  inp: [G; IN_780],
+const INPUT_SIZE_783: usize = 2;
+const IN_783: usize = 2;
+const OUT_783: usize = 1;
+fn aiur_fn_783(
+  inp: [G; IN_783],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_780], ExecError> {
+) -> Result<[G; OUT_783], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_780] = [__v_0];
-        record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_783] = [__v_0];
+        record.function_queries[783].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_780] = { let __args: [G; IN_780] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } else { aiur_fn_780(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } else { aiur_fn_783(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
@@ -65826,8 +65269,8 @@ fn aiur_fn_780(
         let __v_10: G = __loaded[5];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_780] = [__v_10];
-            record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_783] = [__v_10];
+            record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65839,15 +65282,15 @@ fn aiur_fn_780(
   })
 }
 
-const INPUT_SIZE_781: usize = 2;
-const IN_781: usize = 2;
-const OUT_781: usize = 1;
-fn aiur_fn_781(
-  inp: [G; IN_781],
+const INPUT_SIZE_784: usize = 2;
+const IN_784: usize = 2;
+const OUT_784: usize = 1;
+fn aiur_fn_784(
+  inp: [G; IN_784],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_781], ExecError> {
+) -> Result<[G; OUT_784], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65856,8 +65299,8 @@ fn aiur_fn_781(
         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_781] = [__v_4];
-        record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_784] = [__v_4];
+        record.function_queries[784].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65870,11 +65313,11 @@ fn aiur_fn_781(
             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_781] = { let __args: [G; IN_781] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[784].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_784] = unsafe { *(result.output.as_ptr() as *const [G; OUT_784]) }; __ret } else { aiur_fn_784(__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_781] = [__v_9];
-            record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_784] = [__v_9];
+            record.function_queries[784].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65886,15 +65329,15 @@ fn aiur_fn_781(
   })
 }
 
-const INPUT_SIZE_782: usize = 1;
-const IN_782: usize = 1;
-const OUT_782: usize = 1;
-fn aiur_fn_782(
-  inp: [G; IN_782],
+const INPUT_SIZE_785: usize = 1;
+const IN_785: usize = 1;
+const OUT_785: usize = 1;
+fn aiur_fn_785(
+  inp: [G; IN_785],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_782], ExecError> {
+) -> Result<[G; OUT_785], 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 };
@@ -65937,17 +65380,17 @@ fn aiur_fn_782(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_37: G = G::from_u64(0);
-        let __ret: [G; OUT_782] = [__v_37];
-        record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_785] = [__v_37];
+        record.function_queries[785].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } else { aiur_fn_782(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__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_782] = [__v_39];
-        record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_785] = [__v_39];
+        record.function_queries[785].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65957,15 +65400,15 @@ fn aiur_fn_782(
   })
 }
 
-const INPUT_SIZE_783: usize = 1;
-const IN_783: usize = 1;
-const OUT_783: usize = 1;
-fn aiur_fn_783(
-  inp: [G; IN_783],
+const INPUT_SIZE_786: usize = 1;
+const IN_786: usize = 1;
+const OUT_786: usize = 1;
+fn aiur_fn_786(
+  inp: [G; IN_786],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_783], ExecError> {
+) -> Result<[G; OUT_786], 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 };
@@ -65978,17 +65421,17 @@ fn aiur_fn_783(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_783] = [__v_7];
-        record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_786] = [__v_7];
+        record.function_queries[786].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } else { aiur_fn_783(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[786].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_786] = unsafe { *(result.output.as_ptr() as *const [G; OUT_786]) }; __ret } else { aiur_fn_786(__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_783] = [__v_9];
-        record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_786] = [__v_9];
+        record.function_queries[786].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65998,15 +65441,15 @@ fn aiur_fn_783(
   })
 }
 
-const INPUT_SIZE_784: usize = 2;
-const IN_784: usize = 2;
-const OUT_784: usize = 1;
-fn aiur_fn_784(
-  inp: [G; IN_784],
+const INPUT_SIZE_787: usize = 2;
+const IN_787: usize = 2;
+const OUT_787: usize = 1;
+fn aiur_fn_787(
+  inp: [G; IN_787],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_784], ExecError> {
+) -> Result<[G; OUT_787], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66015,8 +65458,8 @@ fn aiur_fn_784(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_784] = [__v_4];
-        record.function_queries[784].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_787] = [__v_4];
+        record.function_queries[787].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66032,11 +65475,11 @@ fn aiur_fn_784(
             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 __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[784].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_784] = unsafe { *(result.output.as_ptr() as *const [G; OUT_784]) }; __ret } else { aiur_fn_784(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[787].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_787] = unsafe { *(result.output.as_ptr() as *const [G; OUT_787]) }; __ret } else { aiur_fn_787(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = { let __values: [G; 6] = [__v_8, __v_3, __v_4, __v_5, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_784] = [__v_12];
-            record.function_queries[784].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_787] = [__v_12];
+            record.function_queries[787].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66048,28 +65491,28 @@ fn aiur_fn_784(
   })
 }
 
-const INPUT_SIZE_785: usize = 2;
-const IN_785: usize = 2;
-const OUT_785: usize = 1;
-fn aiur_fn_785(
-  inp: [G; IN_785],
+const INPUT_SIZE_788: usize = 2;
+const IN_788: usize = 2;
+const OUT_788: usize = 1;
+fn aiur_fn_788(
+  inp: [G; IN_788],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_785], ExecError> {
+) -> Result<[G; OUT_788], 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_785] = [__v_0];
-        record.function_queries[785].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_788] = [__v_0];
+        record.function_queries[788].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_785] = { let __args: [G; IN_785] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__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];
@@ -66077,8 +65520,8 @@ fn aiur_fn_785(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_785] = [__v_7];
-            record.function_queries[785].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_788] = [__v_7];
+            record.function_queries[788].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66090,15 +65533,15 @@ fn aiur_fn_785(
   })
 }
 
-const INPUT_SIZE_786: usize = 1;
-const IN_786: usize = 1;
-const OUT_786: usize = 1;
-fn aiur_fn_786(
-  inp: [G; IN_786],
+const INPUT_SIZE_789: usize = 1;
+const IN_789: usize = 1;
+const OUT_789: usize = 1;
+fn aiur_fn_789(
+  inp: [G; IN_789],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_786], ExecError> {
+) -> Result<[G; OUT_789], 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 };
@@ -66110,17 +65553,17 @@ fn aiur_fn_786(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_786] = [__v_6];
-        record.function_queries[786].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_789] = [__v_6];
+        record.function_queries[789].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[786].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_786] = unsafe { *(result.output.as_ptr() as *const [G; OUT_786]) }; __ret } else { aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[789].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_789] = unsafe { *(result.output.as_ptr() as *const [G; OUT_789]) }; __ret } else { aiur_fn_789(__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_786] = [__v_8];
-        record.function_queries[786].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_789] = [__v_8];
+        record.function_queries[789].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66130,15 +65573,15 @@ fn aiur_fn_786(
   })
 }
 
-const INPUT_SIZE_787: usize = 9;
-const IN_787: usize = 9;
-const OUT_787: usize = 1;
-fn aiur_fn_787(
-  inp: [G; IN_787],
+const INPUT_SIZE_790: usize = 9;
+const IN_790: usize = 9;
+const OUT_790: usize = 1;
+fn aiur_fn_790(
+  inp: [G; IN_790],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_787], ExecError> {
+) -> Result<[G; OUT_790], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66167,17 +65610,17 @@ fn aiur_fn_787(
         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_787] = [__v_23];
-        record.function_queries[787].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_790] = [__v_23];
+        record.function_queries[790].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__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[787].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_787] = unsafe { *(result.output.as_ptr() as *const [G; OUT_787]) }; __ret } else { aiur_fn_787(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__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[790].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_790] = unsafe { *(result.output.as_ptr() as *const [G; OUT_790]) }; __ret } else { aiur_fn_790(__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_787] = [__v_21];
-        record.function_queries[787].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_790] = [__v_21];
+        record.function_queries[790].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66187,15 +65630,15 @@ fn aiur_fn_787(
   })
 }
 
-const INPUT_SIZE_788: usize = 2;
-const IN_788: usize = 2;
-const OUT_788: usize = 1;
-fn aiur_fn_788(
-  inp: [G; IN_788],
+const INPUT_SIZE_791: usize = 2;
+const IN_791: usize = 2;
+const OUT_791: usize = 1;
+fn aiur_fn_791(
+  inp: [G; IN_791],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_788], ExecError> {
+) -> Result<[G; OUT_791], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66205,17 +65648,17 @@ fn aiur_fn_788(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_788] = [__v_1];
-        record.function_queries[788].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_791] = [__v_1];
+        record.function_queries[791].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_788] = { let __args: [G; IN_788] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[791].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_791] = unsafe { *(result.output.as_ptr() as *const [G; OUT_791]) }; __ret } else { aiur_fn_791(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_788] = [__v_7];
-        record.function_queries[788].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_791] = [__v_7];
+        record.function_queries[791].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66225,15 +65668,15 @@ fn aiur_fn_788(
   })
 }
 
-const INPUT_SIZE_789: usize = 8;
-const IN_789: usize = 8;
-const OUT_789: usize = 6;
-fn aiur_fn_789(
-  inp: [G; IN_789],
+const INPUT_SIZE_792: usize = 8;
+const IN_792: usize = 8;
+const OUT_792: usize = 6;
+fn aiur_fn_792(
+  inp: [G; IN_792],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_789], ExecError> {
+) -> Result<[G; OUT_792], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66253,8 +65696,8 @@ fn aiur_fn_789(
         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_789] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15];
-        record.function_queries[789].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_792] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15];
+        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -66275,22 +65718,22 @@ fn aiur_fn_789(
         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_789] = { let __args: [G; IN_789] = [__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[789].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_789] = unsafe { *(result.output.as_ptr() as *const [G; OUT_789]) }; __ret } else { aiur_fn_789(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__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[792].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_792] = unsafe { *(result.output.as_ptr() as *const [G; OUT_792]) }; __ret } else { aiur_fn_792(__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_791] = { let __args: [G; IN_791] = [__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[791].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_791] = unsafe { *(result.output.as_ptr() as *const [G; OUT_791]) }; __ret } else { aiur_fn_791(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_794] = { let __args: [G; IN_794] = [__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[794].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_794] = unsafe { *(result.output.as_ptr() as *const [G; OUT_794]) }; __ret } else { aiur_fn_794(__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_789] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
-            record.function_queries[789].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_792] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
+            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66300,27 +65743,27 @@ fn aiur_fn_789(
                 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_789] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24];
-                record.function_queries[789].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_792] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24];
+                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__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[789].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_789] = unsafe { *(result.output.as_ptr() as *const [G; OUT_789]) }; __ret } else { aiur_fn_789(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__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[792].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_792] = unsafe { *(result.output.as_ptr() as *const [G; OUT_792]) }; __ret } else { aiur_fn_792(__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_791] = { let __args: [G; IN_791] = [__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[791].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_791] = unsafe { *(result.output.as_ptr() as *const [G; OUT_791]) }; __ret } else { aiur_fn_791(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_794] = { let __args: [G; IN_794] = [__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[794].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_794] = unsafe { *(result.output.as_ptr() as *const [G; OUT_794]) }; __ret } else { aiur_fn_794(__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_789] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-                record.function_queries[789].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_792] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
+                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -66334,28 +65777,28 @@ fn aiur_fn_789(
   })
 }
 
-const INPUT_SIZE_790: usize = 2;
-const IN_790: usize = 2;
-const OUT_790: usize = 1;
-fn aiur_fn_790(
-  inp: [G; IN_790],
+const INPUT_SIZE_793: usize = 2;
+const IN_793: usize = 2;
+const OUT_793: usize = 1;
+fn aiur_fn_793(
+  inp: [G; IN_793],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_790], ExecError> {
+) -> Result<[G; OUT_793], 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_790] = [__v_0];
-        record.function_queries[790].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_793] = [__v_0];
+        record.function_queries[793].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_790] = { let __args: [G; IN_790] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[790].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_790] = unsafe { *(result.output.as_ptr() as *const [G; OUT_790]) }; __ret } else { aiur_fn_790(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[793].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_793] = unsafe { *(result.output.as_ptr() as *const [G; OUT_793]) }; __ret } else { aiur_fn_793(__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];
@@ -66365,8 +65808,8 @@ fn aiur_fn_790(
         let __v_9: G = __loaded[4];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_790] = [__v_9];
-            record.function_queries[790].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_793] = [__v_9];
+            record.function_queries[793].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66378,15 +65821,15 @@ fn aiur_fn_790(
   })
 }
 
-const INPUT_SIZE_791: usize = 15;
-const IN_791: usize = 15;
-const OUT_791: usize = 6;
-fn aiur_fn_791(
-  inp: [G; IN_791],
+const INPUT_SIZE_794: usize = 15;
+const IN_794: usize = 15;
+const OUT_794: usize = 6;
+fn aiur_fn_794(
+  inp: [G; IN_794],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_791], ExecError> {
+) -> Result<[G; OUT_794], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66405,38 +65848,38 @@ fn aiur_fn_791(
     let __v_14: G = inp[14];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_2, __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[792].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_792] = unsafe { *(result.output.as_ptr() as *const [G; OUT_792]) }; __ret } else { aiur_fn_792(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_1, __v_2, __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[795].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_795] = unsafe { *(result.output.as_ptr() as *const [G; OUT_795]) }; __ret } else { aiur_fn_795(__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_791] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
-        record.function_queries[791].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_794] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
+        record.function_queries[794].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_791] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17];
-        record.function_queries[791].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_794] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17];
+        record.function_queries[794].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_792: usize = 14;
-const IN_792: usize = 14;
-const OUT_792: usize = 6;
-fn aiur_fn_792(
-  inp: [G; IN_792],
+const INPUT_SIZE_795: usize = 14;
+const IN_795: usize = 14;
+const OUT_795: usize = 6;
+fn aiur_fn_795(
+  inp: [G; IN_795],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_792], ExecError> {
+) -> Result<[G; OUT_795], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66476,8 +65919,8 @@ fn aiur_fn_792(
                     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_792] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28];
-                    record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_795] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28];
+                    record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -66501,8 +65944,8 @@ fn aiur_fn_792(
                             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_792] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
-                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_795] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
+                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -66530,8 +65973,8 @@ fn aiur_fn_792(
                                             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_792] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_795] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66555,8 +65998,8 @@ fn aiur_fn_792(
                                                     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_792] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                    record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_795] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                    record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
@@ -66564,8 +66007,8 @@ fn aiur_fn_792(
                                                     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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                    record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                    record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                 }
@@ -66575,8 +66018,8 @@ fn aiur_fn_792(
                                                 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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66604,8 +66047,8 @@ fn aiur_fn_792(
                                                 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_792] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_795] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66613,8 +66056,8 @@ fn aiur_fn_792(
                                                 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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66624,8 +66067,8 @@ fn aiur_fn_792(
                                             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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66637,8 +66080,8 @@ fn aiur_fn_792(
                                     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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                    record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -66648,8 +66091,8 @@ fn aiur_fn_792(
                                 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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -66681,8 +66124,8 @@ fn aiur_fn_792(
                                         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_792] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_795] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -66706,8 +66149,8 @@ fn aiur_fn_792(
                                                 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_792] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_795] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66715,8 +66158,8 @@ fn aiur_fn_792(
                                                 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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66726,8 +66169,8 @@ fn aiur_fn_792(
                                             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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66755,8 +66198,8 @@ fn aiur_fn_792(
                                             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_792] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_795] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66764,8 +66207,8 @@ fn aiur_fn_792(
                                             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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66775,8 +66218,8 @@ fn aiur_fn_792(
                                         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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
@@ -66788,8 +66231,8 @@ fn aiur_fn_792(
                                 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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -66799,8 +66242,8 @@ fn aiur_fn_792(
                             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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -66830,8 +66273,8 @@ fn aiur_fn_792(
                         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_792] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
-                        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_795] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
+                        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -66859,8 +66302,8 @@ fn aiur_fn_792(
                                         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_792] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_795] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -66884,8 +66327,8 @@ fn aiur_fn_792(
                                                 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_792] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_795] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66893,8 +66336,8 @@ fn aiur_fn_792(
                                                 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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66904,8 +66347,8 @@ fn aiur_fn_792(
                                             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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66933,8 +66376,8 @@ fn aiur_fn_792(
                                             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_792] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_795] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66942,8 +66385,8 @@ fn aiur_fn_792(
                                             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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66953,8 +66396,8 @@ fn aiur_fn_792(
                                         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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
@@ -66966,8 +66409,8 @@ fn aiur_fn_792(
                                 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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -66977,8 +66420,8 @@ fn aiur_fn_792(
                             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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67010,8 +66453,8 @@ fn aiur_fn_792(
                                     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_792] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                    record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_795] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                    record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -67035,8 +66478,8 @@ fn aiur_fn_792(
                                             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_792] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_795] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -67044,8 +66487,8 @@ fn aiur_fn_792(
                                             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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -67055,8 +66498,8 @@ fn aiur_fn_792(
                                         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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
@@ -67084,8 +66527,8 @@ fn aiur_fn_792(
                                         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_792] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_795] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -67093,8 +66536,8 @@ fn aiur_fn_792(
                                         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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
@@ -67104,8 +66547,8 @@ fn aiur_fn_792(
                                     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_792] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                    record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_795] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                    record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -67117,8 +66560,8 @@ fn aiur_fn_792(
                             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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67128,8 +66571,8 @@ fn aiur_fn_792(
                         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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -67163,8 +66606,8 @@ fn aiur_fn_792(
                             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_792] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_795] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
+                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -67188,8 +66631,8 @@ fn aiur_fn_792(
                                     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_792] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                    record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_795] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                    record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -67197,8 +66640,8 @@ fn aiur_fn_792(
                                     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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                    record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -67208,8 +66651,8 @@ fn aiur_fn_792(
                                 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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -67237,8 +66680,8 @@ fn aiur_fn_792(
                                 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_792] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_795] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -67246,8 +66689,8 @@ fn aiur_fn_792(
                                 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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -67257,8 +66700,8 @@ fn aiur_fn_792(
                             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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67270,8 +66713,8 @@ fn aiur_fn_792(
                     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_792] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                    record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_795] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+                    record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -67281,8 +66724,8 @@ fn aiur_fn_792(
                 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_792] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_795] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -67314,8 +66757,8 @@ fn aiur_fn_792(
                         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_792] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_795] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
+                        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -67339,8 +66782,8 @@ fn aiur_fn_792(
                                 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_792] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_795] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -67348,8 +66791,8 @@ fn aiur_fn_792(
                                 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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -67359,8 +66802,8 @@ fn aiur_fn_792(
                             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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67388,8 +66831,8 @@ fn aiur_fn_792(
                             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_792] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_795] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -67397,8 +66840,8 @@ fn aiur_fn_792(
                             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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67408,8 +66851,8 @@ fn aiur_fn_792(
                         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_792] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_795] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -67421,8 +66864,8 @@ fn aiur_fn_792(
                 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_792] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_795] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+                record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -67432,8 +66875,8 @@ fn aiur_fn_792(
             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_792] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_795] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -71414,6 +70857,21 @@ pub(crate) fn execute_generated(
       let __out = aiur_fn_792(__inp, record, io_buffer, false)?;
       return Ok(__out.to_vec());
     },
+    793u64 => {
+      let __inp: [G; IN_793] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_793(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    794u64 => {
+      let __inp: [G; IN_794] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_794(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    795u64 => {
+      let __inp: [G; IN_795] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_795(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
     _ => {
       return Err(ExecError::InvalidFunIdx(fun_idx));
     },